@splitsoftware/splitio-commons 1.17.1-rc.3 → 2.0.0-rc.0

package/esm/storages/inRedis/RedisAdapter.js

@@ -1,7 +1,6 @@
 import { __extends } from "tslib";
 import ioredis from 'ioredis';
 import { merge, isString } from '../../utils/lang';
-import { _Set, setToArray } from '../../utils/lang/sets';
 import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
 var LOG_PREFIX = 'storage:redis-adapter: ';
@@ -17,7 +16,7 @@ var DEFAULT_OPTIONS = {
 var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-    lazyConnect: false // @TODO true to avoid side-effects on instantiation.
+    lazyConnect: false
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
@@ -33,7 +32,7 @@ var RedisAdapter = /** @class */ (function (_super) {
         _this.log = log;
         _this._options = options;
         _this._notReadyCommandsQueue = [];
-        _this._runningCommands = new _Set();
+        _this._runningCommands = new Set();
         _this._listenToEvents();
         _this._setTimeoutWrappers();
         _this._setDisconnectWrapper();
@@ -126,7 +125,7 @@ var RedisAdapter = /** @class */ (function (_super) {
             setTimeout(function deferredDisconnect() {
                 if (instance._runningCommands.size > 0) {
                     instance.log.info(LOG_PREFIX + ("Attempting to disconnect but there are " + instance._runningCommands.size + " commands still waiting for resolution. Defering disconnection until those finish."));
-                    Promise.all(setToArray(instance._runningCommands))
+                    Promise.all(Array.from(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
                         originalMethod.apply(instance, params);

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -197,7 +197,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 return value;
             _this.log.error(LOG_PREFIX + ("Could not read result from get members of flag set " + flagSets[index] + " due to an error: " + e));
         }); })
-            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
+            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
     /**
      * Check traffic type existence.

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -2,7 +2,6 @@ import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
-import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 var TelemetryCacheInRedis = /** @class */ (function () {
@@ -39,7 +38,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
     TelemetryCacheInRedis.prototype.popLatencies = function () {
         var _this = this;
         return this.redis.hgetall(this.keys.latencyPrefix).then(function (latencies) {
-            var result = new _Map();
+            var result = new Map();
             Object.keys(latencies).forEach(function (field) {
                 var parsedField = parseLatencyField(field);
                 if (isString(parsedField)) {
@@ -71,7 +70,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
     TelemetryCacheInRedis.prototype.popExceptions = function () {
         var _this = this;
         return this.redis.hgetall(this.keys.exceptionPrefix).then(function (exceptions) {
-            var result = new _Map();
+            var result = new Map();
             Object.keys(exceptions).forEach(function (field) {
                 var parsedField = parseExceptionField(field);
                 if (isString(parsedField)) {
@@ -98,7 +97,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
     TelemetryCacheInRedis.prototype.popConfigs = function () {
         var _this = this;
         return this.redis.hgetall(this.keys.initPrefix).then(function (configs) {
-            var result = new _Map();
+            var result = new Map();
             Object.keys(configs).forEach(function (field) {
                 var parsedField = parseMetadata(field);
                 if (isString(parsedField)) {

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -1,6 +1,5 @@
 import { __extends } from "tslib";
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
 var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
@@ -22,7 +21,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -167,7 +167,7 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return Promise.all(flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
             return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
-        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
+        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
     /**
      * Check traffic type existence.

package/esm/storages/pluggable/TelemetryCachePluggable.js

@@ -2,7 +2,6 @@ import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { isString, isNaNNumber } from '../../utils/lang';
-import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 var TelemetryCachePluggable = /** @class */ (function () {
@@ -38,7 +37,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(function (latencyKeys) {
             return latencyKeys.length ?
                 _this.wrapper.getMany(latencyKeys).then(function (latencies) {
-                    var result = new _Map();
+                    var result = new Map();
                     for (var i = 0; i < latencyKeys.length; i++) {
                         var field = latencyKeys[i].split('::')[1];
                         var parsedField = parseLatencyField(field);
@@ -65,7 +64,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     return Promise.all(latencyKeys.map(function (latencyKey) { return _this.wrapper.del(latencyKey); })).then(function () { return result; });
                 }) :
                 // If latencyKeys is empty, return an empty map.
-                new _Map();
+                new Map();
         });
     };
     /**
@@ -77,7 +76,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(function (exceptionKeys) {
             return exceptionKeys.length ?
                 _this.wrapper.getMany(exceptionKeys).then(function (exceptions) {
-                    var result = new _Map();
+                    var result = new Map();
                     for (var i = 0; i < exceptionKeys.length; i++) {
                         var field = exceptionKeys[i].split('::')[1];
                         var parsedField = parseExceptionField(field);
@@ -99,7 +98,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     return Promise.all(exceptionKeys.map(function (exceptionKey) { return _this.wrapper.del(exceptionKey); })).then(function () { return result; });
                 }) :
                 // If exceptionKeys is empty, return an empty map.
-                new _Map();
+                new Map();
         });
     };
     /**
@@ -111,7 +110,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(function (configKeys) {
             return configKeys.length ?
                 _this.wrapper.getMany(configKeys).then(function (configs) {
-                    var result = new _Map();
+                    var result = new Map();
                     for (var i = 0; i < configKeys.length; i++) {
                         var field = configKeys[i].split('::')[1];
                         var parsedField = parseMetadata(field);
@@ -131,7 +130,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });
                 }) :
                 // If configKeys is empty, return an empty map.
-                new _Map();
+                new Map();
         });
     };
     return TelemetryCachePluggable;

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -1,6 +1,5 @@
 import { __extends } from "tslib";
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
 import { LOG_PREFIX } from './constants';
 var UniqueKeysCachePluggable = /** @class */ (function (_super) {
@@ -22,7 +21,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/esm/storages/pluggable/inMemoryWrapper.js

@@ -1,5 +1,4 @@
 import { startsWith, toNumber } from '../../utils/lang';
-import { setToArray, _Set } from '../../utils/lang/sets';
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
@@ -87,15 +86,15 @@ export function inMemoryWrapperFactory(connDelay) {
             var set = _cache[key];
             if (!set)
                 return Promise.resolve(false);
-            if (set instanceof _Set)
+            if (set instanceof Set)
                 return Promise.resolve(set.has(item));
             return Promise.reject('key is not a set');
         },
         addItems: function (key, items) {
             if (!(key in _cache))
-                _cache[key] = new _Set();
+                _cache[key] = new Set();
             var set = _cache[key];
-            if (set instanceof _Set) {
+            if (set instanceof Set) {
                 items.forEach(function (item) { return set.add(item); });
                 return Promise.resolve();
             }
@@ -103,9 +102,9 @@ export function inMemoryWrapperFactory(connDelay) {
         },
         removeItems: function (key, items) {
             if (!(key in _cache))
-                _cache[key] = new _Set();
+                _cache[key] = new Set();
             var set = _cache[key];
-            if (set instanceof _Set) {
+            if (set instanceof Set) {
                 items.forEach(function (item) { return set.delete(item); });
                 return Promise.resolve();
             }
@@ -115,8 +114,8 @@ export function inMemoryWrapperFactory(connDelay) {
             var set = _cache[key];
             if (!set)
                 return Promise.resolve([]);
-            if (set instanceof _Set)
-                return Promise.resolve(setToArray(set));
+            if (set instanceof Set)
+                return Promise.resolve(Array.from(set));
             return Promise.reject('key is not a set');
         },
         // always connects and disconnects

package/esm/storages/pluggable/index.js

@@ -55,7 +55,6 @@ export function PluggableStorage(options) {
         var metadata = metadataBuilder(settings);
         var keys = new KeyBuilderSS(prefix, metadata);
         var wrapper = wrapperAdapter(log, options.wrapper);
-        var connectPromise;
         var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
         var telemetry = shouldRecordTelemetry(params) || isSyncronizer ?
@@ -73,6 +72,37 @@ export function PluggableStorage(options) {
                 settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
                 new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
             undefined;
+        // Connects to wrapper and emits SDK_READY event on main client
+        var connectPromise = wrapper.connect().then(function () {
+            if (isSyncronizer) {
+                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+                return wrapper.get(keys.buildHashKey()).then(function (hash) {
+                    var currentHash = getStorageHash(settings);
+                    if (hash !== currentHash) {
+                        log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
+                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
+                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
+                    }
+                }).then(function () {
+                    onReadyCb();
+                });
+            }
+            else {
+                // Start periodic flush of async storages if not running synchronizer (producer mode)
+                if (impressionCountsCache && impressionCountsCache.start)
+                    impressionCountsCache.start();
+                if (uniqueKeysCache && uniqueKeysCache.start)
+                    uniqueKeysCache.start();
+                if (telemetry && telemetry.recordConfig)
+                    telemetry.recordConfig();
+                onReadyCb();
+            }
+        }).catch(function (e) {
+            e = e || new Error('Error connecting wrapper');
+            onReadyCb(e);
+            return e; // Propagate error for shared clients
+        });
         return {
             splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
@@ -81,41 +111,6 @@ export function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
-            init: function () {
-                if (connectPromise)
-                    return connectPromise;
-                // Connects to wrapper and emits SDK_READY event on main client
-                return connectPromise = wrapper.connect().then(function () {
-                    if (isSyncronizer) {
-                        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
-                        return wrapper.get(keys.buildHashKey()).then(function (hash) {
-                            var currentHash = getStorageHash(settings);
-                            if (hash !== currentHash) {
-                                log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                                return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
-                                    return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
-                                }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
-                            }
-                        }).then(function () {
-                            onReadyCb();
-                        });
-                    }
-                    else {
-                        // Start periodic flush of async storages if not running synchronizer (producer mode)
-                        if (impressionCountsCache && impressionCountsCache.start)
-                            impressionCountsCache.start();
-                        if (uniqueKeysCache && uniqueKeysCache.start)
-                            uniqueKeysCache.start();
-                        if (telemetry && telemetry.recordConfig)
-                            telemetry.recordConfig();
-                        onReadyCb();
-                    }
-                }).catch(function (e) {
-                    e = e || new Error('Error connecting wrapper');
-                    onReadyCb(e);
-                    return e; // Propagate error for shared clients
-                });
-            },
             // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
                 return Promise.all(isSyncronizer ? [] : [
@@ -125,7 +120,7 @@ export function PluggableStorage(options) {
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                this.init().then(onReadyCb);
+                connectPromise.then(onReadyCb);
                 return __assign(__assign({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

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

@@ -1,7 +1,7 @@
 import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
 import { CONTROL } from '../../../utils/constants';
-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 { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
@@ -43,8 +43,13 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    // Emits SDK_READY
-                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
+                        // Emits SDK_READY_FROM_CACHE
+                        if (cacheReady)
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                        // Emits SDK_READY
+                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                    });
                 }
                 return true;
             });

package/esm/sync/polling/pollingManagerSS.js

@@ -1,6 +1,5 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for pulling data from services.
@@ -19,9 +18,10 @@ export function pollingManagerSSFactory(params) {
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
             var startingUp = splitsSyncTask.start();
-            if (thenable(startingUp)) {
+            if (startingUp) {
                 startingUp.then(function () {
-                    segmentsSyncTask.start();
+                    if (splitsSyncTask.isRunning())
+                        segmentsSyncTask.start();
                 });
             }
         },

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

@@ -1,6 +1,5 @@
-import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
@@ -20,7 +19,7 @@ function checkAllSegmentsExist(segments) {
  */
 export function parseSegments(_a) {
     var conditions = _a.conditions;
-    var segments = new _Set();
+    var segments = new Set();
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         matchers.forEach(function (matcher) {
@@ -55,7 +54,7 @@ function matchFilters(featureFlag, filters) {
  * Exported for testing purposes.
  */
 export function computeSplitsMutation(entries, filters) {
-    var segments = new _Set();
+    var segments = new Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
             accum.added.push([split.name, split]);
@@ -68,7 +67,7 @@ export function computeSplitsMutation(entries, filters) {
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
-    computed.segments = setToArray(segments);
+    computed.segments = Array.from(segments);
     return computed;
 }
 /**
@@ -121,7 +120,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            return Promise.resolve(splitUpdateNotification ?
+            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -165,6 +164,15 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 }
                 return false;
             });
+            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
+            // Wrapping in a promise since checkCache can be async.
+            if (splitsEventEmitter && startingUp) {
+                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {
+                    if (isCacheReady)
+                        splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+                });
+            }
+            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

package/esm/sync/streaming/parseUtils.js

@@ -8,7 +8,6 @@ function Uint8ArrayToString(myUint8Arr) {
 }
 function StringToUint8Array(myString) {
     var charCodes = myString.split('').map(function (e) { return e.charCodeAt(0); });
-    // eslint-disable-next-line compat/compat
     return new Uint8Array(charCodes);
 }
 /**

package/esm/sync/streaming/pushManager.js

@@ -12,7 +12,6 @@ import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR,
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
-import { _Set } from '../../utils/lang/sets';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
@@ -218,8 +217,8 @@ export function pushManagerFactory(params, pollingManager) {
                 var keyList = void 0, added_1, removed_1;
                 try {
                     keyList = parseKeyList(parsedData.d, parsedData.c);
-                    added_1 = new _Set(keyList.a);
-                    removed_1 = new _Set(keyList.r);
+                    added_1 = new Set(keyList.a);
+                    removed_1 = new Set(keyList.r);
                 }
                 catch (e) {
                     log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', e]);

package/esm/trackers/eventTracker.js

@@ -9,7 +9,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -20,16 +20,14 @@ export function eventTrackerFactory(settings, eventsCache, whenInit, integration
             log.info(EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
                 // Wrap in a timeout because we don't want it to be blocking.
-                whenInit(function () {
-                    setTimeout(function () {
-                        // copy of event, to avoid unexpected behaviour if modified by integrations
-                        var eventDataCopy = objectAssign({}, eventData);
-                        if (properties)
-                            eventDataCopy.properties = objectAssign({}, properties);
-                        // integrationsManager does not throw errors (they are internally handled by each integration module)
-                        integrationsManager.handleEvent(eventDataCopy);
-                    });
-                });
+                setTimeout(function () {
+                    // copy of event, to avoid unexpected behaviour if modified by integrations
+                    var eventDataCopy = objectAssign({}, eventData);
+                    if (properties)
+                        eventDataCopy.properties = objectAssign({}, properties);
+                    // integrationsManager does not throw errors (they are internally handled by each integration module)
+                    integrationsManager.handleEvent(eventDataCopy);
+                }, 0);
             }
         }
         else {

package/esm/trackers/impressionsTracker.js

@@ -11,7 +11,7 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, integrationsManager, telemetryCache) {
+export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -51,20 +51,18 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         sdkLanguageVersion: version
                     };
                     // Wrap in a timeout because we don't want it to be blocking.
-                    whenInit(function () {
-                        setTimeout(function () {
-                            // integrationsManager.handleImpression does not throw errors
-                            if (integrationsManager)
-                                integrationsManager.handleImpression(impressionData);
-                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (impressionListener)
-                                    impressionListener.logImpression(impressionData);
-                            }
-                            catch (err) {
-                                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-                            }
-                        });
-                    });
+                    setTimeout(function () {
+                        // integrationsManager.handleImpression does not throw errors
+                        if (integrationsManager)
+                            integrationsManager.handleImpression(impressionData);
+                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                            if (impressionListener)
+                                impressionListener.logImpression(impressionData);
+                        }
+                        catch (err) {
+                            log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+                        }
+                    }, 0);
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/esm/trackers/uniqueKeysTracker.js

@@ -16,6 +16,9 @@ var noopFilterAdapter = {
 export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -24,11 +27,6 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
-        start: function () {
-            if (filterAdapter.refreshRate) {
-                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-            }
-        },
         stop: function () {
             clearInterval(intervalId);
         }

package/esm/utils/LRUCache/index.js

@@ -1,9 +1,8 @@
-import { _Map } from '../lang/maps';
 import { LinkedList, Node } from './LinkedList';
 var LRUCache = /** @class */ (function () {
     function LRUCache(maxSize) {
         this.maxLen = maxSize || 1;
-        this.items = new _Map();
+        this.items = new Map();
         this.lru = new LinkedList();
     }
     LRUCache.prototype.get = function (key) {

package/esm/utils/constants/browser.js

@@ -1,5 +1,2 @@
-// Integration types
-export var GOOGLE_ANALYTICS_TO_SPLIT = 'GOOGLE_ANALYTICS_TO_SPLIT';
-export var SPLIT_TO_GOOGLE_ANALYTICS = 'SPLIT_TO_GOOGLE_ANALYTICS';
 // This value might be eventually set via a config parameter
 export var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days

package/esm/utils/lang/index.js

@@ -111,11 +111,9 @@ export function isBoolean(val) {
 export function isFiniteNumber(val) {
     if (val instanceof Number)
         val = val.valueOf();
-    // @TODO remove `isFinite` once `Number.isFinite` is fully supported by targets
-    // eslint-disable-next-line compat/compat
-    if (typeof val === 'number')
-        return Number.isFinite ? Number.isFinite(val) : isFinite(val);
-    return false;
+    return typeof val === 'number' ?
+        Number.isFinite ? Number.isFinite(val) : isFinite(val) :
+        false;
 }
 /**
  * Checks if a given value is an integer value of number type or Number object.
@@ -124,10 +122,9 @@ export function isFiniteNumber(val) {
 export function isIntegerNumber(val) {
     if (val instanceof Number)
         val = val.valueOf();
-    // eslint-disable-next-line compat/compat
-    if (typeof val === 'number')
-        return Number.isInteger ? Number.isInteger(val) : isFinite(val) && Math.floor(val) === val;
-    return false;
+    return typeof val === 'number' ?
+        Number.isInteger ? Number.isInteger(val) : isFinite(val) && Math.floor(val) === val :
+        false;
 }
 /**
  * Checks if a given value is a NaN value of number type or Number object.