@splitsoftware/splitio-commons 1.4.1 → 1.4.2-rc.2

package/CHANGES.txt

@@ -1,3 +1,8 @@
+1.5.0 (June 24, 2022)
+- Added a new config option to control the tasks that listen or poll for updates on feature flags and segments, via the new config sync.enabled . Running online Split will always pull the most recent updates upon initialization, this only affects updates fetching on a running instance. Useful when a consistent session experience is a must or to save resources when updates are not being used.
+- Updated telemetry logic to track the anonymous config for user consent flag set to declined or unknown.
+- Updated submitters logic, to avoid duplicating the post of impressions to Split cloud when the SDK is destroyed while its periodic post of impressions is running.
+
 1.4.1 (June 13, 2022)
  - Bugfixing - Updated submitters logic, to avoid dropping impressions and events that are being tracked while POST request is pending.
 

package/cjs/consent/sdkUserConsent.js

@@ -31,10 +31,10 @@ function createUserConsentAPI(params) {
                 log.info(constants_1.USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop
                 settings.userConsent = newConsentStatus;
                 if (consent) { // resumes submitters if transitioning to GRANTED
-                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start();
+                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitterManager) === null || _a === void 0 ? void 0 : _a.start();
                 }
-                else { // pauses submitters and drops tracked data if transitioning to DECLINED
-                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _b === void 0 ? void 0 : _b.stop();
+                else { // pauses submitters (except telemetry), and drops tracked data if transitioning to DECLINED
+                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitterManager) === null || _b === void 0 ? void 0 : _b.stop(true);
                     // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
                     if (events.clear)
                         events.clear(); // @ts-ignore

package/cjs/listeners/browser.js

@@ -53,7 +53,7 @@ var BrowserSignalListener = /** @class */ (function () {
     BrowserSignalListener.prototype.flushData = function () {
         if (!this.syncManager)
             return; // In consumer mode there is not sync manager and data to flush
-        // Flush data if there is user consent
+        // Flush impressions & events data if there is user consent
         if ((0, consent_1.isConsentGranted)(this.settings)) {
             var eventsUrl = this.settings.urls.events;
             var extraMetadata = {
@@ -64,11 +64,12 @@ var BrowserSignalListener = /** @class */ (function () {
             this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
             if (this.storage.impressionCounts)
                 this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, impressionCountsSubmitter_1.fromImpressionCountsCollector);
-            if (this.storage.telemetry) {
-                var telemetryUrl = this.settings.urls.telemetry;
-                var telemetryCacheAdapter = (0, telemetrySubmitter_1.telemetryCacheStatsAdapter)(this.storage.telemetry, this.storage.splits, this.storage.segments);
-                this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
-            }
+        }
+        // Flush telemetry data
+        if (this.storage.telemetry) {
+            var telemetryUrl = this.settings.urls.telemetry;
+            var telemetryCacheAdapter = (0, telemetrySubmitter_1.telemetryCacheStatsAdapter)(this.storage.telemetry, this.storage.splits, this.storage.segments);
+            this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
         }
         // Close streaming connection
         if (this.syncManager.pushManager)

package/cjs/sdkFactory/index.js

@@ -25,13 +25,14 @@ function sdkFactory(params) {
     (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
     var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
+    var matchingKey = (0, key_1.getMatching)(settings.core.key);
     // @TODO consider passing the settings object, so that each storage access only what it needs
     var storageFactoryParams = {
         impressionsQueueSize: settings.scheduler.impressionsQueueSize,
         eventsQueueSize: settings.scheduler.eventsQueueSize,
         optimize: (0, utils_1.shouldBeOptimized)(settings),
         // ATM, only used by InLocalStorage
-        matchingKey: (0, key_1.getMatching)(settings.core.key),
+        matchingKey: matchingKey,
         splitFiltersValidation: settings.sync.__splitFiltersValidation,
         // ATM, only used by PluggableStorage
         mode: settings.mode,
@@ -47,7 +48,21 @@ function sdkFactory(params) {
         log: log
     };
     var storage = storageFactory(storageFactoryParams);
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    // @TODO dataLoader requires validation
+    if (settings.dataLoader) {
+        settings.dataLoader(storage, matchingKey);
+        Promise.resolve(storage.splits.checkCache()).then(function (cacheReady) {
+            if (cacheReady) {
+                if (settings.sync.onlySubmitters) { // emit SDK_READY to not timeout when not synchronizing splits & segments
+                    readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
+                    readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+                }
+                else { // emit SDK_READY_FROM_CACHE
+                    readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+                }
+            }
+        });
+    }
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     // trackers
     var observer = impressionsObserverFactory && impressionsObserverFactory();
@@ -79,6 +94,9 @@ function sdkFactory(params) {
         // Logger wrapper API
         Logger: (0, sdkLogger_1.createLoggerAPI)(settings.log),
         settings: settings,
+        // @TODO remove
+        __storage: storage,
+        __ctx: ctx
     }, extraProps && extraProps(ctx));
 }
 exports.sdkFactory = sdkFactory;

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -33,7 +33,7 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
      */
     AbstractSplitsCacheSync.prototype.checkCache = function () {
-        return false;
+        return this.getChangeNumber() > -1;
     };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.

package/cjs/storages/dataLoader.js

@@ -1,26 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataLoaderFactory = void 0;
+exports.DataLoaderFactory = void 0;
 var browser_1 = require("../utils/constants/browser");
 /**
- * Factory of client-side storage loader
+ * Factory of storage loader
  *
  * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
  * and extended with a `mySegmentsData` property.
  * @returns function to preload the storage
  */
-function dataLoaderFactory(preloadedData) {
+function DataLoaderFactory(preloadedData) {
     /**
      * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
      * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
      *
      * @param storage object containing `splits` and `segments` cache (client-side variant)
-     * @param userId user key string of the provided MySegmentsCache
+     * @param userKey user key (matching key) of the provided MySegmentsCache
      *
-     * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
      * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
+     * @TODO add logs, and input validation in this module, in favor of size reduction.
+     * @TODO unit tests
      */
-    return function loadData(storage, userId) {
+    return function loadData(storage, userKey) {
         // Do not load data if current preloadedData is empty
         if (Object.keys(preloadedData).length === 0)
             return;
@@ -36,16 +37,23 @@ function dataLoaderFactory(preloadedData) {
         storage.splits.setChangeNumber(since);
         // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
         storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return [splitName, splitsData[splitName]]; }));
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-        if (!mySegmentsData) {
-            // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
-            mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+        if (userKey) { // add mySegments data (client-side)
+            var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
+            if (!mySegmentsData) {
+                // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
+                mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
+                    var userKeys = segmentsData[segmentName];
+                    return userKeys.indexOf(userKey) > -1;
+                });
+            }
+            storage.segments.resetSegments(mySegmentsData);
+        }
+        else { // add segments data (server-side)
+            Object.keys(segmentsData).filter(function (segmentName) {
+                var userKeys = segmentsData[segmentName];
+                storage.segments.addToSegment(segmentName, userKeys);
             });
         }
-        storage.segments.resetSegments(mySegmentsData);
     };
 }
-exports.dataLoaderFactory = dataLoaderFactory;
+exports.DataLoaderFactory = DataLoaderFactory;

package/cjs/storages/inMemory/InMemoryStorage.js

@@ -8,6 +8,7 @@ var EventsCacheInMemory_1 = require("./EventsCacheInMemory");
 var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -28,7 +29,20 @@ function InMemoryStorageFactory(params) {
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
-        }
+        },
+        // @ts-ignore, private method, for POC
+        getSnapshot: function () {
+            var _this = this;
+            return {
+                lastUpdated: Date.now(),
+                since: this.splits.changeNumber,
+                splitsData: this.splits.splitsCache,
+                segmentsData: Object.keys(this.segments.segmentCache).reduce(function (prev, cur) {
+                    prev[cur] = (0, sets_1.setToArray)(_this.segments.segmentCache[cur]);
+                    return prev;
+                }, {})
+            };
+        },
     };
 }
 exports.InMemoryStorageFactory = InMemoryStorageFactory;

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -29,6 +29,18 @@ function InMemoryStorageCSFactory(params) {
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
         },
+        // @ts-ignore, private method, for POC
+        getSnapshot: function () {
+            var _a;
+            return {
+                lastUpdated: Date.now(),
+                since: this.splits.changeNumber,
+                splitsData: this.splits.splitsCache,
+                mySegmentsData: (_a = {},
+                    _a[params.matchingKey] = Object.keys(this.segments.segmentCache),
+                    _a)
+            };
+        },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {

package/cjs/sync/submitters/submitterManager.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.submitterManagerFactory = void 0;
-var syncTaskComposite_1 = require("../syncTaskComposite");
 var eventsSubmitter_1 = require("./eventsSubmitter");
 var impressionsSubmitter_1 = require("./impressionsSubmitter");
 var impressionCountsSubmitter_1 = require("./impressionCountsSubmitter");
@@ -15,8 +14,33 @@ function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
-    if (telemetrySubmitter)
-        submitters.push(telemetrySubmitter);
-    return (0, syncTaskComposite_1.syncTaskComposite)(submitters);
+    return {
+        // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+        start: function (onlyTelemetry) {
+            if (!onlyTelemetry)
+                submitters.forEach(function (submitter) { return submitter.start(); });
+            if (telemetrySubmitter)
+                telemetrySubmitter.start();
+        },
+        // `allExceptTelemetry` true if userConsent is changed to DECLINED
+        stop: function (allExceptTelemetry) {
+            submitters.forEach(function (submitter) { return submitter.stop(); });
+            if (!allExceptTelemetry && telemetrySubmitter)
+                telemetrySubmitter.stop();
+        },
+        isRunning: function () {
+            return submitters.some(function (submitter) { return submitter.isRunning(); });
+        },
+        // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+        execute: function (onlyTelemetry) {
+            var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
+            if (telemetrySubmitter)
+                promises.push(telemetrySubmitter.execute());
+            return Promise.all(promises);
+        },
+        isExecuting: function () {
+            return submitters.some(function (submitter) { return submitter.isExecuting(); });
+        }
+    };
 }
 exports.submitterManagerFactory = submitterManagerFactory;

package/cjs/sync/syncManagerOnline.js

@@ -19,16 +19,16 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
      * SyncManager factory for modular SDK
      */
     return function (params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, telemetryTracker = params.telemetryTracker;
+        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, _b = _a.sync, syncEnabled = _b.enabled, onlySubmitters = _b.onlySubmitters, telemetryTracker = params.telemetryTracker;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
+        var pollingManager = onlySubmitters ? undefined : pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
-        var pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+        var pushManager = syncEnabled && 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 = (0, submitterManager_1.submitterManagerFactory)(params);
+        var submitterManager = (0, submitterManager_1.submitterManagerFactory)(params);
         /** Sync Manager logic */
         function startPolling() {
             if (pollingManager.isRunning()) {
@@ -61,7 +61,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
             // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
             pollingManager: pollingManager,
             pushManager: pushManager,
-            submitter: submitter,
+            submitterManager: submitterManager,
             /**
              * Method used to start the syncManager for the first time, or resume it after being stopped.
              */
@@ -69,21 +69,29 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 running = true;
                 // start syncing splits and segments
                 if (pollingManager) {
-                    if (pushManager) {
-                        // Doesn't call `syncAll` when the syncManager is resuming
+                    // If synchronization is disabled pushManager and pollingManager should not start
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            // Doesn't call `syncAll` when the syncManager is resuming
+                            if (startFirstTime) {
+                                pollingManager.syncAll();
+                                startFirstTime = false;
+                            }
+                            pushManager.start();
+                        }
+                        else {
+                            pollingManager.start();
+                        }
+                    }
+                    else {
                         if (startFirstTime) {
                             pollingManager.syncAll();
                             startFirstTime = false;
                         }
-                        pushManager.start();
-                    }
-                    else {
-                        pollingManager.start();
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                if ((0, consent_1.isConsentGranted)(settings))
-                    submitter.start();
+                submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
             },
             /**
              * Method used to stop/pause the syncManager.
@@ -96,16 +104,13 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 if (pollingManager && pollingManager.isRunning())
                     pollingManager.stop();
                 // stop periodic data recording (events, impressions, telemetry).
-                submitter.stop();
+                submitterManager.stop();
             },
             isRunning: function () {
                 return running;
             },
             flush: function () {
-                if ((0, consent_1.isConsentGranted)(settings))
-                    return submitter.execute();
-                else
-                    return Promise.resolve();
+                return submitterManager.execute(!(0, consent_1.isConsentGranted)(settings));
             },
             // [Only used for client-side]
             // If polling and push managers are defined (standalone mode), they implement the interfaces for client-side
@@ -116,22 +121,28 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 return {
                     isRunning: mySegmentsSyncTask.isRunning,
                     start: function () {
-                        if (pushManager) {
-                            if (pollingManager.isRunning()) {
-                                // if doing polling, we must start the periodic fetch of data
-                                if (storage.splits.usesSegments())
-                                    mySegmentsSyncTask.start();
+                        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 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();
+                                if (storage.splits.usesSegments())
+                                    mySegmentsSyncTask.start();
                             }
-                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
-                            if (storage.splits.usesSegments())
-                                mySegmentsSyncTask.start();
+                            if (!readinessManager.isReady())
+                                mySegmentsSyncTask.execute();
                         }
                     },
                     stop: function () {

package/cjs/sync/syncTask.js

@@ -4,8 +4,8 @@ exports.syncTaskFactory = void 0;
 var constants_1 = require("../logger/constants");
 /**
  * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
- * The task can be executed once calling the "execute" method.
- * NOTE: Multiple calls to "execute" are not queued. Use "isExecuting" method to handle synchronization.
+ * The task can be also executed by calling the "execute" method. Multiple execute calls are chained to run secuentially and avoid race conditions.
+ * For example, submitters executed on SDK destroy or full queue, while periodic execution is pending.
  *
  * @param log  Logger instance.
  * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
@@ -15,8 +15,8 @@ var constants_1 = require("../logger/constants");
  */
 function syncTaskFactory(log, task, period, taskName) {
     if (taskName === void 0) { taskName = 'task'; }
-    // Flag that indicates if the task is being executed
-    var executing = false;
+    // Task promise while it is pending. Undefined once the promise is resolved
+    var pendingTask;
     // flag that indicates if the task periodic execution has been started/stopped.
     var running = false;
     // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -30,13 +30,19 @@ function syncTaskFactory(log, task, period, taskName) {
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        executing = true;
+        // If task is executing, chain the new execution
+        if (pendingTask) {
+            return pendingTask.then(function () {
+                return execute.apply(void 0, args);
+            });
+        }
+        // Execute task
         log.debug(constants_1.SYNC_TASK_EXECUTE, [taskName]);
-        return task.apply(void 0, args).then(function (result) {
-            executing = false;
+        pendingTask = task.apply(void 0, args).then(function (result) {
+            pendingTask = undefined;
             return result;
         });
-        // No need to handle promise rejection because it is a pre-condition that provided task never rejects.
+        return pendingTask;
     }
     function periodicExecute(currentRunningId) {
         return execute.apply(void 0, runningArgs).then(function (result) {
@@ -48,10 +54,9 @@ function syncTaskFactory(log, task, period, taskName) {
         });
     }
     return {
-        // @TODO check if we need to queued `execute` calls, to avoid possible race conditions on submitters and updaters with streaming.
         execute: execute,
         isExecuting: function () {
-            return executing;
+            return pendingTask !== undefined;
         },
         start: function () {
             var args = [];

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 (0, murmur3_1.hash)((0, buildKey_1.buildKey)(impression));
+    return (0, murmur3_1.hash)((0, buildKey_1.buildKey)(impression)).toString();
 }
 exports.hashImpression32 = hashImpression32;
 var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes

package/cjs/utils/settingsValidation/index.js

@@ -73,7 +73,8 @@ exports.base = {
         splitFilters: undefined,
         // impressions collection mode
         impressionsMode: constants_1.OPTIMIZED,
-        localhostMode: undefined
+        localhostMode: undefined,
+        enabled: true
     },
     // Logger
     log: undefined
@@ -126,6 +127,9 @@ function settingsValidation(config, validationParams) {
     // ensure a valid SDK mode
     // @ts-ignore, modify readonly prop
     withDefaults.mode = (0, mode_1.mode)(withDefaults.core.authorizationKey, withDefaults.mode);
+    if (withDefaults.sync.onlySubmitters && withDefaults.mode === constants_1.STANDALONE_MODE && !withDefaults.dataLoader) {
+        throw new Error('To use `onlySubmitters` param in standalone mode, DataLoader is required to preload data into the storage');
+    }
     // ensure a valid Storage based on mode defined.
     // @ts-ignore, modify readonly prop
     if (storage)
@@ -167,6 +171,14 @@ function settingsValidation(config, validationParams) {
         // We are not checking if bases are positive numbers. Thus, we might be reauthenticating immediately (`setTimeout` with NaN or negative number)
         scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
     }
+    // validate sync enabled
+    if (withDefaults.sync.enabled !== false) {
+        withDefaults.sync.enabled = true;
+    }
+    // validate sync onlySubmitters
+    if (withDefaults.sync.onlySubmitters !== true) {
+        withDefaults.sync.onlySubmitters = false;
+    }
     // validate the `splitFilters` settings and parse splits query
     var splitFiltersValidation = (0, splitFilters_1.validateSplitFilters)(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;

package/esm/consent/sdkUserConsent.js

@@ -28,10 +28,10 @@ export function createUserConsentAPI(params) {
                 log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop
                 settings.userConsent = newConsentStatus;
                 if (consent) { // resumes submitters if transitioning to GRANTED
-                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start();
+                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitterManager) === null || _a === void 0 ? void 0 : _a.start();
                 }
-                else { // pauses submitters and drops tracked data if transitioning to DECLINED
-                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _b === void 0 ? void 0 : _b.stop();
+                else { // pauses submitters (except telemetry), and drops tracked data if transitioning to DECLINED
+                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitterManager) === null || _b === void 0 ? void 0 : _b.stop(true);
                     // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
                     if (events.clear)
                         events.clear(); // @ts-ignore

package/esm/listeners/browser.js

@@ -50,7 +50,7 @@ var BrowserSignalListener = /** @class */ (function () {
     BrowserSignalListener.prototype.flushData = function () {
         if (!this.syncManager)
             return; // In consumer mode there is not sync manager and data to flush
-        // Flush data if there is user consent
+        // Flush impressions & events data if there is user consent
         if (isConsentGranted(this.settings)) {
             var eventsUrl = this.settings.urls.events;
             var extraMetadata = {
@@ -61,11 +61,12 @@ var BrowserSignalListener = /** @class */ (function () {
             this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
             if (this.storage.impressionCounts)
                 this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
-            if (this.storage.telemetry) {
-                var telemetryUrl = this.settings.urls.telemetry;
-                var telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
-                this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
-            }
+        }
+        // Flush telemetry data
+        if (this.storage.telemetry) {
+            var telemetryUrl = this.settings.urls.telemetry;
+            var telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
+            this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
         }
         // Close streaming connection
         if (this.syncManager.pushManager)

package/esm/sdkFactory/index.js

@@ -8,7 +8,7 @@ import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * Modular SDK factory
@@ -22,13 +22,14 @@ export function sdkFactory(params) {
     validateAndTrackApiKey(log, settings.core.authorizationKey);
     var sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
+    var matchingKey = getMatching(settings.core.key);
     // @TODO consider passing the settings object, so that each storage access only what it needs
     var storageFactoryParams = {
         impressionsQueueSize: settings.scheduler.impressionsQueueSize,
         eventsQueueSize: settings.scheduler.eventsQueueSize,
         optimize: shouldBeOptimized(settings),
         // ATM, only used by InLocalStorage
-        matchingKey: getMatching(settings.core.key),
+        matchingKey: matchingKey,
         splitFiltersValidation: settings.sync.__splitFiltersValidation,
         // ATM, only used by PluggableStorage
         mode: settings.mode,
@@ -44,7 +45,21 @@ export function sdkFactory(params) {
         log: log
     };
     var storage = storageFactory(storageFactoryParams);
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    // @TODO dataLoader requires validation
+    if (settings.dataLoader) {
+        settings.dataLoader(storage, matchingKey);
+        Promise.resolve(storage.splits.checkCache()).then(function (cacheReady) {
+            if (cacheReady) {
+                if (settings.sync.onlySubmitters) { // emit SDK_READY to not timeout when not synchronizing splits & segments
+                    readiness.splits.emit(SDK_SPLITS_ARRIVED);
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                }
+                else { // emit SDK_READY_FROM_CACHE
+                    readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                }
+            }
+        });
+    }
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     // trackers
     var observer = impressionsObserverFactory && impressionsObserverFactory();
@@ -76,5 +91,8 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(settings.log),
         settings: settings,
+        // @TODO remove
+        __storage: storage,
+        __ctx: ctx
     }, extraProps && extraProps(ctx));
 }

package/esm/storages/AbstractSplitsCacheSync.js

@@ -30,7 +30,7 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
      */
     AbstractSplitsCacheSync.prototype.checkCache = function () {
-        return false;
+        return this.getChangeNumber() > -1;
     };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.