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

package/esm/sync/streaming/pushManager.js

@@ -19,10 +19,11 @@ import { hash64 } from '../../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
  */
-export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platform, settings) {
+export 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 ? getMatching(settings.core.key) : undefined; //
+    var userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
     var log = settings.log;
     var sseClient;
     try {
@@ -33,13 +34,14 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(fetchAuth);
+    var authenticate = authenticateFactory(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter);
     sseClient.setEventHandler(sseHandler);
     // init workers
-    var segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+    // MySegmentsUpdateWorker (client-side) are initiated in `add` method
+    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
     var splitsUpdateWorker = new 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
@@ -47,17 +49,13 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
     // [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 = hashUserKey(userKey);
-        userKeyHashes[hash] = userKey;
-        clients[userKey] = { hash64: 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(connectPush, settings.scheduler.pushRetryBackoffBase);
@@ -258,33 +256,46 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
     return 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: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
+                clients[userKey] = { hash64: hash64(userKey), worker: new 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) {

package/esm/sync/submitters/eventsSyncTask.js

@@ -1,28 +1,40 @@
 import { submitterSyncTaskFactory } from './submitterSyncTask';
-import { SUBMITTERS_PUSH_FULL_EVENTS_QUEUE } from '../../logger/constants';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+var DATA_NAME = 'events';
 /**
  * Sync task that periodically posts tracked events
  */
 export function eventsSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, eventsFirstPushWindow, latencyTracker) {
     // don't retry events.
-    var syncTask = submitterSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, 'queued events', latencyTracker);
-    // Set a timer for the first push of events,
+    var syncTask = 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(SUBMITTERS_PUSH_FULL_EVENTS_QUEUE);
-        syncTask.execute();
+        if (syncTask.isRunning()) {
+            log.info(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/esm/sync/submitters/impressionsSyncTask.js

@@ -1,5 +1,7 @@
 import { groupBy, forOwn } from '../../utils/lang';
 import { submitterSyncTaskFactory } from './submitterSyncTask';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+var DATA_NAME = 'impressions';
 /**
  * Converts `impressions` data from cache into request payload.
  */
@@ -32,5 +34,15 @@ export function fromImpressionsCollector(sendLabels, data) {
 export function impressionsSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, sendLabels, latencyTracker) {
     if (sendLabels === void 0) { sendLabels = false; }
     // retry impressions only once.
-    return submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, 'impressions', latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+    var syncTask = 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(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/esm/sync/submitters/submitterManager.js

@@ -2,7 +2,8 @@ import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSyncTaskFactory } from './eventsSyncTask';
 import { impressionsSyncTaskFactory } from './impressionsSyncTask';
 import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
-export function submitterManagerFactory(settings, storage, splitApi) {
+export function submitterManagerFactory(params) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi;
     var log = settings.log;
     var submitters = [
         impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),

package/esm/sync/syncManagerOnline.js

@@ -1,6 +1,7 @@
 import { submitterManagerFactory } from './submitters/submitterManager';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
+import { isConsentGranted } from '../utils/consent';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -13,26 +14,25 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
     /**
      * 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 = submitterManagerFactory(settings, storage, splitApi);
+        var submitter = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
-            if (!pollingManager.isRunning()) {
-                log.info(SYNC_START_POLLING);
-                pollingManager.start();
+            if (pollingManager.isRunning()) {
+                log.info(SYNC_CONTINUE_POLLING);
             }
             else {
-                log.info(SYNC_CONTINUE_POLLING);
+                log.info(SYNC_START_POLLING);
+                pollingManager.start();
             }
         }
         function stopPollingAndSyncAll() {
@@ -50,11 +50,16 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
         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) {
@@ -70,28 +75,27 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                submitter && submitter.start();
-                running = true;
+                if (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 (isConsentGranted(settings))
                     return submitter.execute();
                 else
                     return Promise.resolve();

package/esm/trackers/eventTracker.js

@@ -1,13 +1,17 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
+import { isStorageSync } from './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
  */
-export function eventTrackerFactory(log, eventsCache, integrationsManager) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager) {
+    var log = settings.log;
+    var isSync = 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.
@@ -33,6 +37,9 @@ export function eventTrackerFactory(log, eventsCache, integrationsManager) {
     }
     return {
         track: function (eventData, size) {
+            if (settings.userConsent === CONSENT_DECLINED) {
+                return isSync ? false : Promise.resolve(false);
+            }
             var tracked = eventsCache.track(eventData, size);
             if (thenable(tracked)) {
                 return tracked.then(queueEventsCallback.bind(null, eventData));

package/esm/trackers/impressionObserver/utils.js

@@ -1,4 +1,4 @@
-import { CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
 /**
  * Checks if impressions previous time should be added or not.
  */
@@ -13,3 +13,9 @@ export function shouldBeOptimized(settings) {
         return false;
     return settings.sync.impressionsMode === OPTIMIZED ? true : false;
 }
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isStorageSync(settings) {
+    return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
+}

package/esm/trackers/impressionsTracker.js

@@ -2,6 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { truncateTimeFrame } from '../utils/time';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -12,16 +13,16 @@ import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIO
  * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
  * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
-export function impressionsTrackerFactory(log, impressionsCache, 
-// @TODO consider passing only an optional integrationsManager to handle impressions
-_a, impressionListener, integrationsManager, 
+export function impressionsTrackerFactory(settings, impressionsCache, integrationsManager, 
 // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
 observer, 
 // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
 countsCache) {
-    var _b = _a.runtime, ip = _b.ip, hostname = _b.hostname, version = _a.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
+            if (settings.userConsent === CONSENT_DECLINED)
+                return;
             var impressionsCount = impressions.length;
             var impressionsToStore = []; // Track only the impressions that are going to be stored
             // Wraps impressions to store and adds previousTime if it corresponds
@@ -65,7 +66,7 @@ countsCache) {
                         // integrationsManager.handleImpression does not throw errors
                         if (integrationsManager)
                             integrationsManager.handleImpression(impressionData);
-                        try { // An exception on the listeners should not break the SDK.
+                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
                             if (impressionListener)
                                 impressionListener.logImpression(impressionData);
                         }

package/esm/utils/consent.js

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

package/esm/utils/constants/index.js

@@ -24,3 +24,7 @@ export var STORAGE_MEMORY = 'MEMORY';
 export var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
 export var STORAGE_REDIS = 'REDIS';
 export var STORAGE_PLUGGABLE = 'PLUGGABLE';
+// User consent
+export var CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
+export var CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
+export var CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions

package/esm/utils/inputValidation/attributes.js

@@ -3,7 +3,7 @@ import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 export function validateAttributes(log, maybeAttrs, method) {
     // Attributes are optional
-    if (isObject(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+    if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
         return maybeAttrs;
     log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
     return false;

package/esm/utils/inputValidation/eventProperties.js

@@ -1,4 +1,5 @@
-import { isObject, shallowClone, isString, isFiniteNumber, isBoolean } from '../lang';
+import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
+import { objectAssign } from '../lang/objectAssign';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
 var ECMA_SIZES = {
     NULL: 0,
@@ -17,7 +18,8 @@ export function validateEventProperties(log, maybeProperties, method) {
         return { properties: false, size: BASE_EVENT_SIZE };
     }
     var keys = Object.keys(maybeProperties);
-    var clone = shallowClone(maybeProperties);
+    // Shallow clone
+    var clone = objectAssign({}, maybeProperties);
     // To avoid calculating the size twice we'll return it from here.
     var output = {
         properties: clone,

package/esm/utils/inputValidation/key.js

@@ -35,7 +35,8 @@ export function validateKey(log, maybeKey, method) {
         var bucketingKey = validateKeyValue(log, maybeKey.bucketingKey, method, 'bucketingKey');
         if (matchingKey && bucketingKey)
             return {
-                matchingKey: matchingKey, bucketingKey: bucketingKey
+                matchingKey: matchingKey,
+                bucketingKey: bucketingKey
             };
         log.error(ERROR_INVALID_KEY_OBJECT, [method]);
         return false;

package/esm/utils/lang/index.js

@@ -1,4 +1,4 @@
-import { __spreadArrays } from "tslib";
+import { __spreadArray } from "tslib";
 /**
  * Checks if the target string ends with the sub string.
  */
@@ -141,10 +141,12 @@ export function isNaNNumber(val) {
     return val !== val;
 }
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
 export function isObject(obj) {
-    return obj !== null && typeof obj === 'object' && obj.constructor === Object;
+    return obj !== null && typeof obj === 'object' && (obj.constructor === Object ||
+        (obj.constructor != null && obj.constructor.name === 'Object'));
 }
 /**
  * Checks if a given value is a string.
@@ -152,6 +154,12 @@ export function isObject(obj) {
 export function isString(val) {
     return typeof val === 'string' || val instanceof String;
 }
+/**
+ * String sanitizer. Returns the provided value converted to uppercase if it is a string.
+ */
+export function stringToUpperCase(val) {
+    return isString(val) ? val.toUpperCase() : val;
+}
 /**
  * Deep copy version of Object.assign using recursion.
  * There are some assumptions here. It's for internal use and we don't need verbose errors
@@ -179,21 +187,10 @@ export function merge(target, source) {
     });
     if (rest && rest.length) {
         var nextSource = rest.splice(0, 1)[0];
-        res = merge.apply(void 0, __spreadArrays([res, nextSource], rest));
+        res = merge.apply(void 0, __spreadArray([res, nextSource], rest, false));
     }
     return res;
 }
-/**
- * Shallow clone an object
- */
-export function shallowClone(obj) {
-    var keys = Object.keys(obj);
-    var output = {};
-    for (var i = 0; i < keys.length; i++) {
-        output[keys[i]] = obj[keys[i]];
-    }
-    return output;
-}
 /**
  * Checks if the target string starts with the sub string.
  */

package/esm/utils/lang/maps.js

@@ -68,4 +68,17 @@ var MapPoly = /** @class */ (function () {
     return MapPoly;
 }());
 export { MapPoly };
-export var _Map = typeof Map !== 'undefined' ? Map : MapPoly;
+/**
+ * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),
+ * a ponyfill with minimal features is returned instead.
+ *
+ * Exported for testing purposes only.
+ */
+export function __getMapConstructor() {
+    // eslint-disable-next-line compat/compat
+    if (typeof Array.from === 'function' && typeof Map === 'function' && Map.prototype && Map.prototype.values) {
+        return Map;
+    }
+    return MapPoly;
+}
+export var _Map = __getMapConstructor();

package/esm/utils/murmur3/legacy.js

@@ -0,0 +1,39 @@
+// Deprecated hashing function, used for split bucketing. Replaced by murmur3
+//
+// JAVA reference implementation for the hashing function.
+//
+// int h = 0;
+// for (int i = 0; i < key.length(); i++) {
+//     h = 31 * h + key.charAt(i);
+// }
+// return h ^ seed; // XOR the hash and seed
+//
+function ToInteger(x) {
+    x = Number(x);
+    return x < 0 ? Math.ceil(x) : Math.floor(x);
+}
+function modulo(a, b) {
+    return a - Math.floor(a / b) * b;
+}
+function ToUint32(x) {
+    return modulo(ToInteger(x), Math.pow(2, 32));
+}
+function ToInt32(x) {
+    var uint32 = ToUint32(x);
+    if (uint32 >= Math.pow(2, 31)) {
+        return uint32 - Math.pow(2, 32);
+    }
+    else {
+        return uint32;
+    }
+}
+export function hash(str, seed) {
+    var h = 0;
+    for (var i = 0; i < str.length; i++) {
+        h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
+    }
+    return ToInt32(h ^ seed);
+}
+export function bucket(str, seed) {
+    return Math.abs(hash(str, seed) % 100) + 1;
+}

package/esm/utils/promise/timeout.js

@@ -3,7 +3,7 @@ export function timeout(ms, promise) {
         return promise;
     return new Promise(function (resolve, reject) {
         var tid = setTimeout(function () {
-            reject(new Error("Operation timed out because it exceeded the configured time limit of " + ms + "ms."));
+            reject(new Error("Operation timed out because it exceeded the configured time limit of " + ms + " ms."));
         }, ms);
         promise.then(function (res) {
             clearTimeout(tid);

package/esm/utils/settingsValidation/consent.js

@@ -0,0 +1,12 @@
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
+import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
+import { stringToUpperCase } from '../lang';
+var userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
+export function validateConsent(_a) {
+    var userConsent = _a.userConsent, log = _a.log;
+    userConsent = stringToUpperCase(userConsent);
+    if (userConsentValues.indexOf(userConsent) > -1)
+        return userConsent;
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);
+    return CONSENT_GRANTED;
+}

package/esm/utils/settingsValidation/impressionsMode.js

@@ -1,10 +1,10 @@
-import { ERROR_INVALID_IMPRESSIONS_MODE } from '../../logger/constants';
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
 import { DEBUG, OPTIMIZED } from '../constants';
+import { stringToUpperCase } from '../lang';
 export function validImpressionsMode(log, impressionsMode) {
-    impressionsMode = impressionsMode.toUpperCase();
-    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) === -1) {
-        log.error(ERROR_INVALID_IMPRESSIONS_MODE, [[DEBUG, OPTIMIZED], OPTIMIZED]);
-        impressionsMode = OPTIMIZED;
-    }
-    return impressionsMode;
+    impressionsMode = stringToUpperCase(impressionsMode);
+    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1)
+        return impressionsMode;
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
+    return OPTIMIZED;
 }