@splitsoftware/splitio-commons 1.17.1-rc.4 → 2.0.0-rc.1

package/src/storages/inMemory/UniqueKeysCacheInMemory.ts

@@ -1,12 +1,12 @@
 import { IUniqueKeysCacheBase } from '../types';
-import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+import { setToArray } from '../../utils/lang/sets';
 
 /**
  * Converts `uniqueKeys` data from cache into request payload for SS.
  */
-export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
+export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: Set<string> }): UniqueKeysPayloadSs {
   const payload = [];
   const featureNames = Object.keys(uniqueKeys);
   for (let i = 0; i < featureNames.length; i++) {
@@ -27,7 +27,7 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
   protected onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  protected uniqueKeysTracker: { [featureName: string]: ISet<string> } = {};
+  protected uniqueKeysTracker: { [featureName: string]: Set<string> } = {};
 
   constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {
     this.maxStorage = uniqueKeysQueueSize;
@@ -41,7 +41,7 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
    * Store unique keys per feature.
    */
   track(userKey: string, featureName: string) {
-    if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new _Set();
+    if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new Set();
     const tracker = this.uniqueKeysTracker[featureName];
     if (!tracker.has(userKey)) {
       tracker.add(userKey);

package/src/storages/inMemory/UniqueKeysCacheInMemoryCS.ts

@@ -1,14 +1,14 @@
 import { IUniqueKeysCacheBase } from '../types';
-import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+import { setToArray } from '../../utils/lang/sets';
 
 export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
 
   private onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  private uniqueKeysTracker: { [userKey: string]: ISet<string> } = {};
+  private uniqueKeysTracker: { [userKey: string]: Set<string> } = {};
 
   /**
    *
@@ -28,7 +28,7 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
    */
   track(userKey: string, featureName: string) {
 
-    if (!this.uniqueKeysTracker[userKey]) this.uniqueKeysTracker[userKey] = new _Set();
+    if (!this.uniqueKeysTracker[userKey]) this.uniqueKeysTracker[userKey] = new Set();
     const tracker = this.uniqueKeysTracker[userKey];
     if (!tracker.has(featureName)) {
       tracker.add(featureName);
@@ -66,7 +66,7 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   /**
    * Converts `uniqueKeys` data from cache into request payload.
    */
-  private fromUniqueKeysCollector(uniqueKeys: { [userKey: string]: ISet<string> }): UniqueKeysPayloadCs {
+  private fromUniqueKeysCollector(uniqueKeys: { [userKey: string]: Set<string> }): UniqueKeysPayloadCs {
     const payload = [];
     const userKeys = Object.keys(uniqueKeys);
     for (let k = 0; k < userKeys.length; k++) {

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,9 +1,9 @@
 import ioredis, { Pipeline } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { merge, isString } from '../../utils/lang';
-import { _Set, setToArray, ISet } from '../../utils/lang/sets';
 import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
+import { setToArray } from '../../utils/lang/sets';
 
 const LOG_PREFIX = 'storage:redis-adapter: ';
 
@@ -37,7 +37,7 @@ export class RedisAdapter extends ioredis {
   private readonly log: ILogger;
   private _options: object;
   private _notReadyCommandsQueue?: IRedisCommand[];
-  private _runningCommands: ISet<Promise<any>>;
+  private _runningCommands: Set<Promise<any>>;
 
   constructor(log: ILogger, storageSettings: Record<string, any> = {}) {
     const options = RedisAdapter._defineOptions(storageSettings);
@@ -47,7 +47,7 @@ export class RedisAdapter extends ioredis {
     this.log = log;
     this._options = options;
     this._notReadyCommandsQueue = [];
-    this._runningCommands = new _Set();
+    this._runningCommands = new Set();
     this._listenToEvents();
     this._setTimeoutWrappers();
     this._setDisconnectWrapper();

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
 
 /**
@@ -215,14 +215,14 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of feature flag names per flag set,
    * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
     return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
       .then((results) => results.map(([e, value], index) => {
         if (e === null) 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(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
+      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
   }
 
   /**

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -6,7 +6,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';
 import type { RedisAdapter } from './RedisAdapter';
@@ -46,7 +45,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popLatencies(): Promise<MultiMethodLatencies> {
     return this.redis.hgetall(this.keys.latencyPrefix).then(latencies => {
 
-      const result: MultiMethodLatencies = new _Map();
+      const result: MultiMethodLatencies = new Map();
 
       Object.keys(latencies).forEach(field => {
 
@@ -86,7 +85,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popExceptions(): Promise<MultiMethodExceptions> {
     return this.redis.hgetall(this.keys.exceptionPrefix).then(exceptions => {
 
-      const result: MultiMethodExceptions = new _Map();
+      const result: MultiMethodExceptions = new Map();
 
       Object.keys(exceptions).forEach(field => {
 
@@ -119,7 +118,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popConfigs(): Promise<MultiConfigs> {
     return this.redis.hgetall(this.keys.initPrefix).then(configs => {
 
-      const result: MultiConfigs = new _Map();
+      const result: MultiConfigs = new Map();
 
       Object.keys(configs).forEach(field => {
 

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -1,11 +1,11 @@
 import { IUniqueKeysCacheBase } from '../types';
 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';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
 import type { RedisAdapter } from './RedisAdapter';
+import { setToArray } from '../../utils/lang/sets';
 
 export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -5,7 +5,6 @@ import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { _Set } from '../../utils/lang/sets';
 
 /**
  * ISegmentsCacheAsync implementation for pluggable storages.

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -5,7 +5,7 @@ import { ILogger } from '../../logger/types';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -181,11 +181,11 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of feature flag names per flag set.
    * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
    */
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
     return Promise.all(flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
       return this.wrapper.getItems(flagSetKey).catch(() => []);
-    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
+    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
   }
 
   /**

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -6,7 +6,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';
 
@@ -43,7 +42,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
       return latencyKeys.length ?
         this.wrapper.getMany(latencyKeys).then(latencies => {
 
-          const result: MultiMethodLatencies = new _Map();
+          const result: MultiMethodLatencies = new Map();
 
           for (let i = 0; i < latencyKeys.length; i++) {
             const field = latencyKeys[i].split('::')[1];
@@ -77,7 +76,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
           return Promise.all(latencyKeys.map((latencyKey) => this.wrapper.del(latencyKey))).then(() => result);
         }) :
         // If latencyKeys is empty, return an empty map.
-        new _Map();
+        new Map();
     });
   }
 
@@ -90,7 +89,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
       return exceptionKeys.length ?
         this.wrapper.getMany(exceptionKeys).then(exceptions => {
 
-          const result: MultiMethodExceptions = new _Map();
+          const result: MultiMethodExceptions = new Map();
 
           for (let i = 0; i < exceptionKeys.length; i++) {
             const field = exceptionKeys[i].split('::')[1];
@@ -117,7 +116,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
           return Promise.all(exceptionKeys.map((exceptionKey) => this.wrapper.del(exceptionKey))).then(() => result);
         }) :
         // If exceptionKeys is empty, return an empty map.
-        new _Map();
+        new Map();
     });
   }
 
@@ -130,7 +129,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
       return configKeys.length ?
         this.wrapper.getMany(configKeys).then(configs => {
 
-          const result: MultiConfigs = new _Map();
+          const result: MultiConfigs = new Map();
 
           for (let i = 0; i < configKeys.length; i++) {
             const field = configKeys[i].split('::')[1];
@@ -154,7 +153,7 @@ export class TelemetryCachePluggable implements ITelemetryCacheAsync {
           return Promise.all(configKeys.map((configKey) => this.wrapper.del(configKey))).then(() => result);
         }) :
         // If configKeys is empty, return an empty map.
-        new _Map();
+        new Map();
     });
   }
 }

package/src/storages/pluggable/UniqueKeysCachePluggable.ts

@@ -1,10 +1,10 @@
 import { IPluggableStorageWrapper, IUniqueKeysCacheBase } from '../types';
 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';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
+import { setToArray } from '../../utils/lang/sets';
 
 export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -1,6 +1,6 @@
 import { IPluggableStorageWrapper } from '../types';
 import { startsWith, toNumber } from '../../utils/lang';
-import { ISet, setToArray, _Set } from '../../utils/lang/sets';
+import { setToArray } from '../../utils/lang/sets';
 
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
@@ -9,9 +9,9 @@ import { ISet, setToArray, _Set } from '../../utils/lang/sets';
  *
  * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
-export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
+export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | Set<string>>, _setConnDelay(connDelay: number): void } {
 
-  let _cache: Record<string, string | string[] | ISet<string>> = {};
+  let _cache: Record<string, string | string[] | Set<string>> = {};
   let _connDelay = connDelay;
 
   return {
@@ -84,22 +84,22 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     itemContains(key: string, item: string) {
       const set = _cache[key];
       if (!set) return Promise.resolve(false);
-      if (set instanceof _Set) return Promise.resolve(set.has(item));
+      if (set instanceof Set) return Promise.resolve(set.has(item));
       return Promise.reject('key is not a set');
     },
     addItems(key: string, items: string[]) {
-      if (!(key in _cache)) _cache[key] = new _Set();
+      if (!(key in _cache)) _cache[key] = new Set();
       const set = _cache[key];
-      if (set instanceof _Set) {
+      if (set instanceof Set) {
         items.forEach(item => set.add(item));
         return Promise.resolve();
       }
       return Promise.reject('key is not a set');
     },
     removeItems(key: string, items: string[]) {
-      if (!(key in _cache)) _cache[key] = new _Set();
+      if (!(key in _cache)) _cache[key] = new Set();
       const set = _cache[key];
-      if (set instanceof _Set) {
+      if (set instanceof Set) {
         items.forEach(item => set.delete(item));
         return Promise.resolve();
       }
@@ -108,7 +108,7 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     getItems(key: string) {
       const set = _cache[key];
       if (!set) return Promise.resolve([]);
-      if (set instanceof _Set) return Promise.resolve(setToArray(set));
+      if (set instanceof Set) return Promise.resolve(setToArray(set));
       return Promise.reject('key is not a set');
     },
 

package/src/storages/types.ts

@@ -2,7 +2,6 @@ import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
-import { ISet } from '../utils/lang/sets';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -211,7 +210,7 @@ export interface ISplitsCacheBase {
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
   checkCache(): MaybeThenable<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>,
-  getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>
+  getNamesByFlagSets(flagSets: string[]): MaybeThenable<Set<string>[]>
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
@@ -228,7 +227,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   clear(): void,
   checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
-  getNamesByFlagSets(flagSets: string[]): ISet<string>[]
+  getNamesByFlagSets(flagSets: string[]): Set<string>[]
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
@@ -245,7 +244,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
 }
 
 /** Segments cache */

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -1,4 +1,3 @@
-import { _Set, setToArray, ISet } from '../../../utils/lang/sets';
 import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } from '../../../dtos/types';
@@ -9,6 +8,7 @@ import { ILogger } from '../../../logger/types';
 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';
+import { setToArray } from '../../../utils/lang/sets';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
@@ -27,8 +27,8 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
  * Collect segments from a raw split definition.
  * Exported for testing purposes.
  */
-export function parseSegments({ conditions }: ISplit): ISet<string> {
-  let segments = new _Set<string>();
+export function parseSegments({ conditions }: ISplit): Set<string> {
+  let segments = new Set<string>();
 
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;
@@ -74,7 +74,7 @@ function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
  * Exported for testing purposes.
  */
 export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersValidation): ISplitMutations {
-  const segments = new _Set<string>();
+  const segments = new Set<string>();
   const computed = entries.reduce((accum, split) => {
     if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
       accum.added.push([split.name, split]);

package/src/sync/streaming/parseUtils.ts

@@ -13,7 +13,6 @@ function Uint8ArrayToString(myUint8Arr: Uint8Array) { // @ts-ignore
 
 function StringToUint8Array(myString: string) {
   const charCodes = myString.split('').map((e) => e.charCodeAt(0));
-  // eslint-disable-next-line compat/compat
   return new Uint8Array(charCodes);
 }
 

package/src/sync/streaming/pushManager.ts

@@ -15,7 +15,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 { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
-import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
@@ -254,11 +253,11 @@ export function pushManagerFactory(
         return;
       }
       case UpdateStrategy.KeyList: {
-        let keyList: KeyList, added: ISet<string>, removed: ISet<string>;
+        let keyList: KeyList, added: Set<string>, removed: Set<string>;
         try {
           keyList = parseKeyList(parsedData.d!, parsedData.c!);
-          added = new _Set(keyList.a);
-          removed = new _Set(keyList.r);
+          added = new Set(keyList.a);
+          removed = new Set(keyList.r);
         } catch (e) {
           log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', e]);
           break;

package/src/sync/submitters/types.ts

@@ -1,7 +1,6 @@
 /* eslint-disable no-use-before-define */
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
-import { IMap } from '../../utils/lang/maps';
 import { ISyncTask } from '../types';
 
 export type ImpressionsPayload = {
@@ -88,11 +87,11 @@ export type StoredEventWithMetadata = {
   e: SplitIO.EventData
 }
 
-export type MultiMethodLatencies = IMap<string, MethodLatencies>
+export type MultiMethodLatencies = Map<string, MethodLatencies>
 
-export type MultiMethodExceptions = IMap<string, MethodExceptions>
+export type MultiMethodExceptions = Map<string, MethodExceptions>
 
-export type MultiConfigs = IMap<string, TelemetryConfigStats>
+export type MultiConfigs = Map<string, TelemetryConfigStats>
 
 /**
  * Telemetry usage stats

package/src/types.ts

@@ -71,7 +71,6 @@ export interface ISettings {
   readonly core: {
     authorizationKey: string,
     key: SplitIO.SplitKey,
-    trafficType?: string,
     labelsEnabled: boolean,
     IPAddressesEnabled: boolean
   },
@@ -923,12 +922,6 @@ export namespace SplitIO {
        * @property {SplitKey} key
        */
       key: SplitKey,
-      /**
-       * Traffic type associated with the customer identifier. @see {@link https://help.split.io/hc/en-us/articles/360019916311-Traffic-type}
-       * If no provided as a setting it will be required on the client.track() calls.
-       * @property {string} trafficType
-       */
-      trafficType?: string,
       /**
        * Disable labels from being sent to Split backend. Labels may contain sensitive information.
        * @property {boolean} labelsEnabled
@@ -1037,10 +1030,9 @@ export namespace SplitIO {
      * Returns a shared client of the SDK, with the given key and optional traffic type.
      * @function client
      * @param {SplitKey} key The key for the new client instance.
-     * @param {string=} trafficType The traffic type of the provided key.
      * @returns {ICsClient} The client instance.
      */
-    client(key: SplitKey, trafficType?: string): ICsClient,
+    client(key: SplitKey): ICsClient,
     /**
      * Returns a manager instance of the SDK to explore available information.
      * @function manager

package/src/utils/LRUCache/index.ts

@@ -1,14 +1,13 @@
-import { IMap, _Map } from '../lang/maps';
 import { LinkedList, Node } from './LinkedList';
 
 export class LRUCache<K, V> {
   maxLen: number;
-  items: IMap<K, Node<{ key: K, value: V }>>;
+  items: Map<K, Node<{ key: K, value: V }>>;
   lru: LinkedList<{ key: K, value: V }>;
 
   constructor(maxSize?: number) {
     this.maxLen = maxSize || 1;
-    this.items = new _Map();
+    this.items = new Map();
     this.lru = new LinkedList();
   }
 

package/src/utils/constants/browser.ts

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

package/src/utils/lang/index.ts

@@ -122,10 +122,9 @@ export function isBoolean(val: any): boolean {
  */
 export function isFiniteNumber(val: any): boolean {
   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;
 }
 
 /**
@@ -134,9 +133,9 @@ export function isFiniteNumber(val: any): boolean {
  */
 export function isIntegerNumber(val: any): boolean {
   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;
 }
 
 /**