@splitsoftware/splitio-commons 1.2.1-rc.1 → 1.2.1-rc.12

package/cjs/utils/settingsValidation/index.js

@@ -6,6 +6,8 @@ var mode_1 = require("./mode");
 var splitFilters_1 = require("./splitFilters");
 var constants_1 = require("../constants");
 var impressionsMode_1 = require("./impressionsMode");
+var key_1 = require("../inputValidation/key");
+var trafficType_1 = require("../inputValidation/trafficType");
 var base = {
     // Define which kind of object you want to retrieve from SplitFactory
     mode: constants_1.STANDALONE_MODE,
@@ -36,6 +38,8 @@ var base = {
         eventsPushRate: 60,
         // how many events will be queued before flushing
         eventsQueueSize: 500,
+        // how many impressions will be queued before flushing
+        impressionsQueueSize: 30000,
         // backoff base seconds to wait before re attempting to connect to push notifications
         pushRetryBackoffBase: 1,
     },
@@ -67,10 +71,6 @@ var base = {
         impressionsMode: constants_1.OPTIMIZED,
         localhostMode: undefined
     },
-    runtime: {
-        ip: false,
-        hostname: false
-    },
     // Logger
     log: undefined
 };
@@ -85,9 +85,9 @@ function fromSecondsToMillis(n) {
  * @param validationParams defaults and fields validators used to validate and creates a settings object from a given config
  */
 function settingsValidation(config, validationParams) {
-    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost;
+    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost, consent = validationParams.consent;
     // creates a settings object merging base, defaults and config objects.
-    var withDefaults = lang_1.merge({}, base, defaults, config);
+    var withDefaults = (0, lang_1.merge)({}, base, defaults, config);
     // ensure a valid logger.
     // First thing to validate, since other validators might use the logger.
     var log = logger(withDefaults); // @ts-ignore, modify readonly prop
@@ -106,19 +106,34 @@ function settingsValidation(config, validationParams) {
     startup.eventsFirstPushWindow = fromSecondsToMillis(startup.eventsFirstPushWindow);
     // ensure a valid SDK mode
     // @ts-ignore, modify readonly prop
-    withDefaults.mode = mode_1.mode(withDefaults.core.authorizationKey, withDefaults.mode);
+    withDefaults.mode = (0, mode_1.mode)(withDefaults.core.authorizationKey, withDefaults.mode);
     // ensure a valid Storage based on mode defined.
     // @ts-ignore, modify readonly prop
     if (storage)
         withDefaults.storage = storage(withDefaults);
-    // Although `key` is mandatory according to TS declaration files, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
-    if (withDefaults.mode === constants_1.LOCALHOST_MODE && withDefaults.core.key === undefined) {
-        withDefaults.core.key = 'localhost_key';
+    // Validate key and TT (for client-side)
+    if (validationParams.acceptKey) {
+        var maybeKey = withDefaults.core.key;
+        // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
+        if (withDefaults.mode === constants_1.LOCALHOST_MODE && maybeKey === undefined) {
+            withDefaults.core.key = 'localhost_key';
+        }
+        else {
+            // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+            // `false` value is used as binded key/TT of the default client, which leads to some issues.
+            // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
+            withDefaults.core.key = (0, key_1.validateKey)(log, maybeKey, 'Client instantiation');
+        }
+        if (validationParams.acceptTT) {
+            var maybeTT = withDefaults.core.trafficType;
+            if (maybeTT !== undefined) { // @ts-ignore
+                withDefaults.core.trafficType = (0, trafficType_1.validateTrafficType)(log, maybeTT, 'Client instantiation');
+            }
+        }
     }
     // Current ip/hostname information
     // @ts-ignore, modify readonly prop
-    if (runtime)
-        withDefaults.runtime = runtime(withDefaults);
+    withDefaults.runtime = runtime(withDefaults);
     // ensure a valid list of integrations.
     // `integrations` returns an array of valid integration items.
     // @ts-ignore, modify readonly prop
@@ -134,11 +149,14 @@ function settingsValidation(config, validationParams) {
         scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
     }
     // validate the `splitFilters` settings and parse splits query
-    var splitFiltersValidation = splitFilters_1.validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
+    var splitFiltersValidation = (0, splitFilters_1.validateSplitFilters)(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
     // ensure a valid impressionsMode
-    withDefaults.sync.impressionsMode = impressionsMode_1.validImpressionsMode(log, withDefaults.sync.impressionsMode);
+    withDefaults.sync.impressionsMode = (0, impressionsMode_1.validImpressionsMode)(log, withDefaults.sync.impressionsMode);
+    // ensure a valid user consent value
+    // @ts-ignore, modify readonly prop
+    withDefaults.userConsent = consent(withDefaults);
     return withDefaults;
 }
 exports.settingsValidation = settingsValidation;

package/cjs/utils/settingsValidation/integrations/configurable.js

@@ -13,6 +13,6 @@ var lang_1 = require("../../lang");
  */
 function validateConfigurableIntegrations(settings, validIntegrationTypes) {
     if (validIntegrationTypes === void 0) { validIntegrationTypes = []; }
-    return common_1.validateIntegrations(settings, function (integration) { return integration && lang_1.isString(integration.type) && validIntegrationTypes.indexOf(integration.type) > -1; }, 'Integration items must have a valid "type" value');
+    return (0, common_1.validateIntegrations)(settings, function (integration) { return integration && (0, lang_1.isString)(integration.type) && validIntegrationTypes.indexOf(integration.type) > -1; }, 'Integration items must have a valid "type" value');
 }
 exports.validateConfigurableIntegrations = validateConfigurableIntegrations;

package/cjs/utils/settingsValidation/integrations/pluggable.js

@@ -10,6 +10,6 @@ var common_1 = require("./common");
  * @returns {Array} array of valid integration factories. The array might be empty if `settings` object does not have valid integrations.
  */
 function validatePluggableIntegrations(settings) {
-    return common_1.validateIntegrations(settings, function (integration) { return typeof integration === 'function'; }, 'Integration items must be functions that initialize the integrations');
+    return (0, common_1.validateIntegrations)(settings, function (integration) { return typeof integration === 'function'; }, 'Integration items must be functions that initialize the integrations');
 }
 exports.validatePluggableIntegrations = validatePluggableIntegrations;

package/cjs/utils/settingsValidation/localhost/builtin.js

@@ -12,7 +12,7 @@ var pluggable_1 = require("./pluggable");
  */
 function validateLocalhostWithDefault(settings) {
     if (!settings.sync.localhostMode)
-        return LocalhostFromObject_1.LocalhostFromObject();
-    return pluggable_1.validateLocalhost(settings) || LocalhostFromObject_1.LocalhostFromObject();
+        return (0, LocalhostFromObject_1.LocalhostFromObject)();
+    return (0, pluggable_1.validateLocalhost)(settings) || (0, LocalhostFromObject_1.LocalhostFromObject)();
 }
 exports.validateLocalhostWithDefault = validateLocalhostWithDefault;

package/cjs/utils/settingsValidation/logger/builtinLogger.js

@@ -19,14 +19,14 @@ var ENV_VAR_KEY = 'SPLITIO_DEBUG';
  */
 var initialState = String(
 // eslint-disable-next-line no-undef
-isNode_1.isNode ? process.env[ENV_VAR_KEY] : isLocalStorageAvailable_1.isLocalStorageAvailable() ? localStorage.getItem(LS_KEY) : '');
+isNode_1.isNode ? process.env[ENV_VAR_KEY] : (0, isLocalStorageAvailable_1.isLocalStorageAvailable)() ? localStorage.getItem(LS_KEY) : '');
 // By default it starts disabled.
 var initialLogLevel = logger_1.LogLevels.NONE;
 // Kept to avoid a breaking change ('on', 'enable' and 'enabled' are equivalent)
 if (/^(enabled?|on)/i.test(initialState)) {
     initialLogLevel = logger_1.LogLevels.DEBUG;
 }
-else if (logger_1.isLogLevelString(initialState)) {
+else if ((0, logger_1.isLogLevelString)(initialState)) {
     initialLogLevel = initialState;
 }
 /**
@@ -37,7 +37,7 @@ else if (logger_1.isLogLevelString(initialState)) {
  */
 function validateLogger(settings) {
     var debug = settings.debug;
-    var logLevel = debug !== undefined ? commons_1.getLogLevel(debug) : initialLogLevel;
+    var logLevel = debug !== undefined ? (0, commons_1.getLogLevel)(debug) : initialLogLevel;
     var log = new logger_1.Logger({ logLevel: logLevel || initialLogLevel }, allCodes);
     // @ts-ignore // if logLevel is undefined at this point, it means that settings `debug` value is invalid
     if (!logLevel)

package/cjs/utils/settingsValidation/logger/commons.js

@@ -18,7 +18,7 @@ function getLogLevel(debugValue) {
             return logger_1.LogLevels.NONE;
         }
     }
-    else if (typeof debugValue === 'string' && logger_1.isLogLevelString(debugValue)) {
+    else if (typeof debugValue === 'string' && (0, logger_1.isLogLevelString)(debugValue)) {
         return debugValue;
     }
     else {

package/cjs/utils/settingsValidation/logger/pluggableLogger.js

@@ -21,7 +21,7 @@ function validateLogger(settings) {
     if (debug !== undefined) {
         if (isLogger(debug))
             return debug;
-        logLevel = commons_1.getLogLevel(settings.debug);
+        logLevel = (0, commons_1.getLogLevel)(settings.debug);
     }
     var log = new logger_1.Logger({ logLevel: logLevel || initialLogLevel });
     // @ts-ignore // `debug` value is invalid if logLevel is undefined at this point

package/cjs/utils/settingsValidation/runtime.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRuntime = void 0;
+// For client-side SDKs, machine IP and Hostname are not captured and sent to Split backend.
+function validateRuntime() {
+    return {
+        ip: false,
+        hostname: false
+    };
+}
+exports.validateRuntime = validateRuntime;

package/cjs/utils/settingsValidation/splitFilters.js

@@ -36,7 +36,7 @@ function validateFilterType(maybeFilterType) {
  */
 function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
-    var result = splits_1.validateSplits(log, values, constants_2.LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
+    var result = (0, splits_1.validateSplits)(log, values, constants_2.LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
     if (result) {
         // check max length
         if (result.length > maxLength)

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -5,7 +5,7 @@ var InMemoryStorageCS_1 = require("../../../storages/inMemory/InMemoryStorageCS"
 var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
 function __InLocalStorageMockFactory(params) {
-    var result = InMemoryStorageCS_1.InMemoryStorageCSFactory(params);
+    var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
     result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
     return result;
 }

package/cjs/utils/timeTracker/index.js

@@ -125,12 +125,12 @@ exports.TrackerAPI = {
      * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
      */
     start: function (log, task, collectors, promise, now) {
-        var taskUniqueId = lang_1.uniqueId();
+        var taskUniqueId = (0, lang_1.uniqueId)();
         var taskCollector = getCollectorForTask(task, collectors);
         var result;
         // If we are registering a promise with this task, we should count the status and the exceptions as well
         // as stopping the task when the promise resolves. Then return the promise
-        if (thenable_1.thenable(promise)) {
+        if ((0, thenable_1.thenable)(promise)) {
             result = this.__attachToPromise(log, promise, task, taskCollector, taskUniqueId);
         }
         else {
@@ -147,7 +147,7 @@ exports.TrackerAPI = {
         var cb = getCallbackForTask(task, taskCollector);
         timers[trackingKey] = {
             cb: cb,
-            timer: timer_1.timer(now)
+            timer: (0, timer_1.timer)(now)
         };
         return result;
     },

package/esm/consent/index.js

@@ -0,0 +1,6 @@
+import { CONSENT_GRANTED } from '../utils/constants';
+export function isConsentGranted(settings) {
+    var userConsent = settings.userConsent;
+    // undefined userConsent is handled as granted (default)
+    return !userConsent || userConsent === CONSENT_GRANTED;
+}

package/esm/consent/sdkUserConsent.js

@@ -0,0 +1,54 @@
+import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED, USER_CONSENT_INITIAL } from '../logger/constants';
+import { isConsentGranted } from './index';
+import { CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../utils/constants';
+import { isBoolean } from '../utils/lang';
+// User consent enum
+var ConsentStatus = {
+    GRANTED: CONSENT_GRANTED,
+    DECLINED: CONSENT_DECLINED,
+    UNKNOWN: CONSENT_UNKNOWN,
+};
+/**
+ * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
+ */
+export function createUserConsentAPI(params) {
+    var settings = params.settings, log = params.settings.log, syncManager = params.syncManager, _a = params.storage, events = _a.events, impressions = _a.impressions, impressionCounts = _a.impressionCounts;
+    if (!isConsentGranted(settings))
+        log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
+    return {
+        setStatus: function (consent) {
+            var _a, _b;
+            // validate input param
+            if (!isBoolean(consent)) {
+                log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+                return false;
+            }
+            var newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
+            if (settings.userConsent !== newConsentStatus) {
+                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();
+                }
+                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();
+                    // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
+                    if (events.clear)
+                        events.clear(); // @ts-ignore
+                    if (impressions.clear)
+                        impressions.clear();
+                    if (impressionCounts)
+                        impressionCounts.clear();
+                }
+            }
+            else {
+                log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
+            }
+            return true;
+        },
+        getStatus: function () {
+            return settings.userConsent;
+        },
+        Status: ConsentStatus
+    };
+}

package/esm/integrations/ga/GoogleAnalyticsToSplit.js

@@ -1,7 +1,9 @@
 import { GaToSplit } from './GaToSplit';
 export function GoogleAnalyticsToSplit(options) {
     // GaToSplit integration factory
-    return function (params) {
+    function GoogleAnalyticsToSplitFactory(params) {
         return GaToSplit(options, params);
-    };
+    }
+    GoogleAnalyticsToSplitFactory.type = 'GOOGLE_ANALYTICS_TO_SPLIT';
+    return GoogleAnalyticsToSplitFactory;
 }

package/esm/integrations/ga/SplitToGoogleAnalytics.js

@@ -2,7 +2,9 @@ import { SplitToGa } from './SplitToGa';
 export function SplitToGoogleAnalytics(options) {
     if (options === void 0) { options = {}; }
     // SplitToGa integration factory
-    return function (params) {
+    function SplitToGoogleAnalyticsFactory(params) {
         return new SplitToGa(params.settings.log, options);
-    };
+    }
+    SplitToGoogleAnalyticsFactory.type = 'SPLIT_TO_GOOGLE_ANALYTICS';
+    return SplitToGoogleAnalyticsFactory;
 }

package/esm/listeners/browser.js

@@ -3,6 +3,7 @@ import { fromImpressionCountsCollector } from '../sync/submitters/impressionCoun
 import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
+import { isConsentGranted } from '../consent';
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 var UNLOAD_DOM_EVENT = 'unload';
 var EVENT_NAME = 'for unload page event.';
@@ -48,15 +49,18 @@ var BrowserSignalListener = /** @class */ (function () {
     BrowserSignalListener.prototype.flushData = function () {
         if (!this.syncManager)
             return; // In consumer mode there is not sync manager and data to flush
-        var eventsUrl = this.settings.urls.events;
-        var extraMetadata = {
-            // sim stands for Sync/Split Impressions Mode
-            sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
-        };
-        this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
-        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);
+        // Flush data if there is user consent
+        if (isConsentGranted(this.settings)) {
+            var eventsUrl = this.settings.urls.events;
+            var extraMetadata = {
+                // sim stands for Sync/Split Impressions Mode
+                sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
+            };
+            this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
+            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);
+        }
         // Close streaming connection
         if (this.syncManager.pushManager)
             this.syncManager.pushManager.stop();
@@ -66,7 +70,7 @@ var BrowserSignalListener = /** @class */ (function () {
         if (!cache.isEmpty()) {
             var dataPayload = fromCacheToPayload ? fromCacheToPayload(cache.state()) : cache.state();
             if (!this._sendBeacon(url, dataPayload, extraMetadata)) {
-                postService(JSON.stringify(dataPayload)).catch(function () { }); // no-op just to catch a possible exceptions
+                postService(JSON.stringify(dataPayload)).catch(function () { }); // no-op just to catch a possible exception
             }
             cache.clear();
         }

package/esm/logger/constants.js

@@ -60,13 +60,16 @@ export var STREAMING_RECONNECT = 111;
 export var STREAMING_CONNECTING = 112;
 export var STREAMING_DISABLED = 113;
 export var STREAMING_DISCONNECTING = 114;
-export var SUBMITTERS_PUSH_FULL_EVENTS_QUEUE = 115;
+export var SUBMITTERS_PUSH_FULL_QUEUE = 115;
 export var SUBMITTERS_PUSH = 116;
 export var SYNC_START_POLLING = 117;
 export var SYNC_CONTINUE_POLLING = 118;
 export var SYNC_STOP_POLLING = 119;
 export var EVENTS_TRACKER_SUCCESS = 120;
 export var IMPRESSIONS_TRACKER_SUCCESS = 121;
+export var USER_CONSENT_UPDATED = 122;
+export var USER_CONSENT_NOT_UPDATED = 123;
+export var USER_CONSENT_INITIAL = 124;
 export var ENGINE_VALUE_INVALID = 200;
 export var ENGINE_VALUE_NO_ATTRIBUTES = 201;
 export var CLIENT_NO_LISTENER = 202;
@@ -112,10 +115,11 @@ export var ERROR_INVALID_KEY_OBJECT = 317;
 export var ERROR_INVALID = 318;
 export var ERROR_EMPTY = 319;
 export var ERROR_EMPTY_ARRAY = 320;
-export var ERROR_INVALID_IMPRESSIONS_MODE = 321;
+export var ERROR_INVALID_CONFIG_PARAM = 321;
 export var ERROR_HTTP = 322;
 export var ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export var ERROR_STORAGE_INVALID = 324;
+export var ERROR_NOT_BOOLEAN = 325;
 // Log prefixes (a.k.a. tags or categories)
 export var LOG_PREFIX_SETTINGS = 'settings';
 export var LOG_PREFIX_INSTANTIATION = 'Factory instantiation';

package/esm/logger/messages/debug.js

@@ -30,9 +30,9 @@ export var codesDebug = codesInfo.concat([
     // SDK
     [c.CLEANUP_REGISTERING, c.LOG_PREFIX_CLEANUP + 'Registering cleanup handler %s'],
     [c.CLEANUP_DEREGISTERING, c.LOG_PREFIX_CLEANUP + 'Deregistering cleanup handler %s'],
-    [c.RETRIEVE_CLIENT_DEFAULT, ' Retrieving default SDK client.'],
-    [c.RETRIEVE_CLIENT_EXISTING, ' Retrieving existing SDK client.'],
-    [c.RETRIEVE_MANAGER, ' Retrieving manager instance.'],
+    [c.RETRIEVE_CLIENT_DEFAULT, 'Retrieving default SDK client.'],
+    [c.RETRIEVE_CLIENT_EXISTING, 'Retrieving existing SDK client.'],
+    [c.RETRIEVE_MANAGER, 'Retrieving manager instance.'],
     // synchronizer
     [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Splits data: \n%s'],
     [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up split update using since = %s'],

package/esm/logger/messages/error.js

@@ -4,7 +4,7 @@ export var codesError = [
     [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid Split, no valid rules found'],
     // SDK
     [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],
-    [c.ERROR_CLIENT_CANNOT_GET_READY, ' The SDK will not get ready. Reason: %s'],
+    [c.ERROR_CLIENT_CANNOT_GET_READY, 'The SDK will not get ready. Reason: %s'],
     [c.ERROR_IMPRESSIONS_TRACKER, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Could not store impressions bulk with %s impression(s). Error: %s'],
     [c.ERROR_IMPRESSIONS_LISTENER, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Impression listener logImpression method threw: %s.'],
     [c.ERROR_EVENTS_TRACKER, c.LOG_PREFIX_EVENTS_TRACKER + 'Failed to queue %s'],
@@ -12,7 +12,7 @@ export var codesError = [
     [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock Splits data, no changes will be applied to the current cache. %s'],
     [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to connect or error on streaming connection, with error message: %s'],
     [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s.'],
-    [c.ERROR_HTTP, ' Response status is not OK. Status: %s. URL: %s. Message: %s'],
+    [c.ERROR_HTTP, 'Response status is not OK. Status: %s. URL: %s. Message: %s'],
     // client status
     [c.ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\'t be emitted again. The callback won\'t be executed.'],
     [c.ERROR_CLIENT_DESTROYED, '%s: Client has already been destroyed - no calls possible.'],
@@ -27,8 +27,9 @@ export var codesError = [
     [c.ERROR_INVALID, '%s: you passed an invalid %s. It must be a non-empty string.'],
     [c.ERROR_EMPTY, '%s: you passed an empty %s. It must be a non-empty string.'],
     [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],
+    [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],
     // initialization / settings validation
-    [c.ERROR_INVALID_IMPRESSIONS_MODE, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "impressionsMode". It should be one of the following values: %s. Defaulting to "%s" mode.'],
+    [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
     [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
     [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': The provided storage is invalid.%s Fallbacking into default MEMORY storage'],
 ];

package/esm/logger/messages/info.js

@@ -8,16 +8,19 @@ export var codesInfo = codesWarn.concat([
     // SDK
     [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Split: %s. Key: %s. Evaluation: %s. Label: %s'],
     [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Queueing corresponding impression.'],
-    [c.NEW_SHARED_CLIENT, ' New shared client instance created.'],
-    [c.NEW_FACTORY, ' New Split SDK instance created.'],
+    [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],
+    [c.NEW_FACTORY, 'New Split SDK instance created.'],
     [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],
     [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],
+    [c.USER_CONSENT_UPDATED, 'setUserConsent: consent status changed from %s to %s.'],
+    [c.USER_CONSENT_NOT_UPDATED, 'setUserConsent: call had no effect because it was the current consent status (%s).'],
+    [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
     // synchronizer
     [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
     [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
     [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
     [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of splits #%s. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FULL_EVENTS_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full events queue and reseting timer.'],
+    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s %s.'],
     [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],
@@ -26,5 +29,5 @@ export var codesInfo = codesWarn.concat([
     [c.STREAMING_DISCONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Disconnecting streaming.'],
     [c.SYNC_START_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming not available. Starting polling.'],
     [c.SYNC_CONTINUE_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming couldn\'t connect. Continue polling.'],
-    [c.SYNC_STOP_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming (re)connected. Syncing and stopping polling.'],
+    [c.SYNC_STOP_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming connected. Syncing and stopping polling.'],
 ]);

package/esm/sdkClient/client.js

@@ -11,7 +11,8 @@ import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
  */
 // @TODO missing time tracking to collect telemetry
 export function clientFactory(params) {
-    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, _a = params.settings, log = _a.log, mode = _a.mode, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker;
+    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker;
+    var log = settings.log, mode = settings.mode;
     function getTreatment(key, splitName, attributes, withConfig) {
         if (withConfig === void 0) { withConfig = false; }
         var wrapUp = function (evaluationResult) {
@@ -96,6 +97,6 @@ export function clientFactory(params) {
         getTreatments: getTreatments,
         getTreatmentsWithConfig: getTreatmentsWithConfig,
         track: track,
-        isBrowserClient: false
+        isClientSide: false
     };
 }

package/esm/sdkClient/clientCS.js

@@ -17,6 +17,6 @@ export function clientCSDecorator(log, client, key, trafficType) {
         getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
         // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
         track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
-        isBrowserClient: true
+        isClientSide: true
     });
 }

package/esm/sdkClient/clientInputValidation.js

@@ -2,12 +2,14 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export function clientInputValidationDecorator(log, client, readinessManager, isStorageSync) {
-    if (isStorageSync === void 0) { isStorageSync = false; }
+export function clientInputValidationDecorator(settings, client, readinessManager) {
+    var log = settings.log;
+    var isSync = isStorageSync(settings);
     /**
      * Avoid repeating this validations code
      */
@@ -27,9 +29,7 @@ export function clientInputValidationDecorator(log, client, readinessManager, is
         };
     }
     function wrapResult(value) {
-        if (isStorageSync)
-            return value;
-        return Promise.resolve(value);
+        return isSync ? value : Promise.resolve(value);
     }
     function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
         var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
@@ -84,9 +84,7 @@ export function clientInputValidationDecorator(log, client, readinessManager, is
             return client.track(key, tt, event, eventValue, properties, size);
         }
         else {
-            if (isStorageSync)
-                return false;
-            return Promise.resolve(false);
+            return isSync ? false : Promise.resolve(false);
         }
     }
     return {

package/esm/sdkClient/sdkClient.js

@@ -1,20 +1,17 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../utils/constants';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export function sdkClientFactory(params) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, sharedClient = params.sharedClient;
+export function sdkClientFactory(params, isSharedClient) {
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings;
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(settings.log, clientFactory(params), sdkReadinessManager.readinessManager, 
-    // storage is async if and only if mode is consumer or partial consumer
-    [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false), 
+    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager), 
     // Sdk destroy
     {
         destroy: function () {
@@ -26,7 +23,7 @@ export function sdkClientFactory(params) {
                 sdkReadinessManager.readinessManager.destroy();
                 signalListener && signalListener.stop();
                 // Release the API Key if it is the main client
-                if (!sharedClient)
+                if (!isSharedClient)
                     releaseApiKey(settings.core.authorizationKey);
                 // Cleanup storage
                 return storage.destroy();

package/esm/sdkClient/sdkClientMethodCS.js

@@ -16,12 +16,7 @@ var method = 'Client instantiation';
  */
 export function sdkClientMethodCSFactory(params) {
     var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, readyTimeout = _a.startup.readyTimeout, log = _a.log;
-    // Keeping similar behaviour as in the isomorphic JS SDK: if settings key is invalid,
-    // `false` value is used as binded key of the default client, but trafficType is ignored
-    // @TODO handle as a non-recoverable error
-    var validKey = validateKey(log, key, method);
-    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
-    validKey);
+    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
     // Cache instances created per factory.
@@ -59,9 +54,8 @@ export function sdkClientMethodCSFactory(params) {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined,
-                sharedClient: true
-            })), validKey);
+                signalListener: undefined, // only the main client "destroy" method stops the signal listener
+            }), true), validKey);
             sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
         }