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

package/esm/utils/lang/sets.js

@@ -1,113 +1,17 @@
-/**
- * Set implementation based on es6-set polyfill (https://github.com/medikoo/es6-set/blob/master/polyfill.js),
- * with the minimal features used by the SDK.
-
-Copyright (C) 2013 Mariusz Nowak (www.medikoo.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-**/
-var SetPoly = /** @class */ (function () {
-    // unlike ES6 `Set`, it only accepts an array as first argument iterable
-    function SetPoly(values) {
-        var _this = this;
-        this.__setData__ = [];
-        if (Array.isArray(values))
-            values.forEach(function (value) { _this.add(value); });
-    }
-    SetPoly.prototype.clear = function () {
-        if (!this.__setData__.length)
-            return;
-        this.__setData__.length = 0;
-    };
-    SetPoly.prototype.add = function (value) {
-        if (this.has(value))
-            return this;
-        this.__setData__.push(value);
-        return this;
-    };
-    SetPoly.prototype.delete = function (value) {
-        var index = this.__setData__.indexOf(value);
-        if (index === -1)
-            return false;
-        this.__setData__.splice(index, 1);
-        return true;
-    };
-    SetPoly.prototype.has = function (value) {
-        return this.__setData__.indexOf(value) !== -1;
-    };
-    SetPoly.prototype.forEach = function (callbackfn, thisArg) {
-        if (typeof callbackfn !== 'function')
-            throw new TypeError(callbackfn + ' is not a function');
-        for (var i = 0; i < this.__setData__.length; i++) {
-            var value = this.__setData__[i];
-            callbackfn.call(thisArg, value, value, this);
-        }
-    };
-    Object.defineProperty(SetPoly.prototype, "size", {
-        get: function () {
-            return this.__setData__.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return SetPoly;
-}());
-export { SetPoly };
-/**
- * return an array containing the items of the given set.
- * @param set Set or SetPoly instance
- */
 export function setToArray(set) {
-    if (set instanceof SetPoly) {
-        return set.__setData__.slice();
-    }
-    // if not using SetPoly as set, it means Array.from is supported
-    // eslint-disable-next-line compat/compat
-    return Array.from(set);
-}
-/**
- * return the Set constructor to use. If `Array.from` built-in or native Set is not available or it doesn't support the required features,
- * a ponyfill with minimal features is returned instead.
- *
- * Exported for testing purposes only.
- */
-export function __getSetConstructor() {
-    // eslint-disable-next-line compat/compat
-    if (typeof Array.from === 'function' && typeof Set === 'function' && Set.prototype && Set.prototype.values) {
-        return Set;
-    }
-    return SetPoly;
+    if (Array.from)
+        return Array.from(set);
+    var array = [];
+    set.forEach(function (value) {
+        array.push(value);
+    });
+    return array;
 }
-export var _Set = __getSetConstructor();
 export function returnSetsUnion(set, set2) {
-    var result = new _Set(setToArray(set));
-    set2.forEach(function (value) {
-        result.add(value);
-    });
-    return result;
+    return new Set(setToArray(set).concat(setToArray(set2)));
 }
 export function returnDifference(list, list2) {
     if (list === void 0) { list = []; }
     if (list2 === void 0) { list2 = []; }
-    var result = new _Set(list);
-    list2.forEach(function (item) {
-        result.delete(item);
-    });
-    return setToArray(result);
+    return list.filter(function (item) { return list2.indexOf(item) === -1; });
 }

package/esm/utils/settingsValidation/index.js

@@ -4,7 +4,6 @@ import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG, FLAG_SPEC_VERSION } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { validateKey } from '../inputValidation/key';
-import { validateTrafficType } from '../inputValidation/trafficType';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
 // Exported for telemetry
 export var base = {
@@ -15,8 +14,6 @@ export var base = {
         authorizationKey: undefined,
         // key used in your system (only required for browser version)
         key: undefined,
-        // traffic type for the given key (only used on browser version)
-        trafficType: undefined,
         // toggle impressions tracking of labels
         labelsEnabled: true,
         // toggle sendind (true) or not sending (false) IP and Host Name with impressions, events, and telemetries requests (only used on nodejs version)
@@ -145,12 +142,6 @@ export function settingsValidation(config, validationParams) {
             // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
             withDefaults.core.key = validateKey(log, maybeKey, LOG_PREFIX_CLIENT_INSTANTIATION);
         }
-        if (validationParams.acceptTT) {
-            var maybeTT = withDefaults.core.trafficType;
-            if (maybeTT !== undefined) { // @ts-ignore
-                withDefaults.core.trafficType = validateTrafficType(log, maybeTT, LOG_PREFIX_CLIENT_INSTANTIATION);
-            }
-        }
     }
     else {
         // On server-side, key is undefined and used to distinguish from client-side

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

@@ -2,9 +2,8 @@ import { isLogLevelString, Logger, LogLevels } from '../../../logger';
 import { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable';
 import { isNode } from '../../env/isNode';
 import { codesDebug } from '../../../logger/messages/debug';
-import { _Map } from '../../lang/maps';
 import { getLogLevel } from './commons';
-var allCodes = new _Map(codesDebug);
+var allCodes = new Map(codesDebug);
 // @TODO set default debug setting instead of initialLogLevel when integrating in JS and Node packages
 var LS_KEY = 'splitio_debug';
 var ENV_VAR_KEY = 'SPLITIO_DEBUG';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.17.1-rc.4",
+  "version": "2.0.0-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -64,7 +64,7 @@
     "@typescript-eslint/parser": "^6.6.0",
     "cross-env": "^7.0.2",
     "eslint": "^8.48.0",
-    "eslint-plugin-compat": "^4.2.0",
+    "eslint-plugin-compat": "^6.0.1",
     "eslint-plugin-import": "^2.25.3",
     "fetch-mock": "^9.11.0",
     "ioredis": "^4.28.0",

package/src/evaluator/Engine.ts

@@ -21,7 +21,7 @@ export class Engine {
 
   constructor(private baseInfo: ISplit, private evaluator: IEvaluator) {
 
-    // in case we don't have a default treatment in the instanciation, use 'control'
+    // in case we don't have a default treatment in the instantiation, use 'control'
     if (typeof this.baseInfo.defaultTreatment !== 'string') {
       this.baseInfo.defaultTreatment = CONTROL;
     }

package/src/evaluator/index.ts

@@ -7,7 +7,7 @@ import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
-import { ISet, setToArray, returnSetsUnion, _Set } from '../utils/lang/sets';
+import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 
 const treatmentException = {
@@ -97,12 +97,12 @@ export function evaluateFeaturesByFlagSets(
   storage: IStorageSync | IStorageAsync,
   method: string,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let storedFlagNames: MaybeThenable<ISet<string>[]>;
+  let storedFlagNames: MaybeThenable<Set<string>[]>;
 
   function evaluate(
-    featureFlagsByFlagSets: ISet<string>[],
+    featureFlagsByFlagSets: Set<string>[],
   ) {
-    let featureFlags = new _Set();
+    let featureFlags = new Set<string>();
     for (let i = 0; i < flagSets.length; i++) {
       const featureFlagByFlagSet = featureFlagsByFlagSets[i];
       if (featureFlagByFlagSet.size) {

package/src/evaluator/matchers/semver_inlist.ts

@@ -1,11 +1,10 @@
-import { _Set } from '../../utils/lang/sets';
 import { Semver } from '../../utils/Semver';
 
 export function inListSemverMatcherContext(ruleAttr: string[]) {
   // @TODO ruleAttr validation should be done at the `parser` or `matchersTransform` level to reuse for all matchers
   if (!ruleAttr || ruleAttr.length === 0) throw new Error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type');
 
-  const listOfSemvers = new _Set(ruleAttr.map((version) => new Semver(version).version));
+  const listOfSemvers = new Set(ruleAttr.map((version) => new Semver(version).version));
 
   return function inListSemverMatcher(runtimeAttr: string): boolean {
     const runtimeSemver = new Semver(runtimeAttr).version;

package/src/evaluator/matchers/whitelist.ts

@@ -1,7 +1,5 @@
-import { _Set } from '../../utils/lang/sets';
-
 export function whitelistMatcherContext(ruleAttr: string[]) {
-  const whitelistSet = new _Set(ruleAttr);
+  const whitelistSet = new Set(ruleAttr);
 
   return function whitelistMatcher(runtimeAttr: string): boolean {
     const isInWhitelist = whitelistSet.has(runtimeAttr);

package/src/listeners/browser.ts

@@ -115,7 +115,6 @@ export class BrowserSignalListener implements ISignalListener {
    * Returns true if beacon API was used successfully, false otherwise.
    */
   private _sendBeacon(url: string, data: any, extraMetadata?: {}) {
-    // eslint-disable-next-line compat/compat
     if (typeof navigator !== 'undefined' && navigator.sendBeacon) {
       const json = {
         entries: data,
@@ -130,7 +129,7 @@ export class BrowserSignalListener implements ISignalListener {
       const payload = JSON.stringify(json);
 
       // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
-      try { // eslint-disable-next-line compat/compat
+      try {
         return navigator.sendBeacon(url, payload);
       } catch (e) {
         return false;

package/src/logger/browser/DebugLogger.ts

@@ -1,7 +1,6 @@
 import { Logger } from '../index';
 import { codesDebug } from '../messages/debug';
-import { _Map } from '../../utils/lang/maps';
 
 export function DebugLogger() {
-  return new Logger({ logLevel: 'DEBUG' }, new _Map(codesDebug));
+  return new Logger({ logLevel: 'DEBUG' }, new Map(codesDebug));
 }

package/src/logger/browser/ErrorLogger.ts

@@ -1,7 +1,6 @@
 import { Logger } from '../index';
 import { codesError } from '../messages/error';
-import { _Map } from '../../utils/lang/maps';
 
 export function ErrorLogger() {
-  return new Logger({ logLevel: 'ERROR' }, new _Map(codesError));
+  return new Logger({ logLevel: 'ERROR' }, new Map(codesError));
 }

package/src/logger/browser/InfoLogger.ts

@@ -1,7 +1,6 @@
 import { Logger } from '../index';
 import { codesInfo } from '../messages/info';
-import { _Map } from '../../utils/lang/maps';
 
 export function InfoLogger() {
-  return new Logger({ logLevel: 'INFO' }, new _Map(codesInfo));
+  return new Logger({ logLevel: 'INFO' }, new Map(codesInfo));
 }

package/src/logger/browser/WarnLogger.ts

@@ -1,7 +1,6 @@
 import { Logger } from '../index';
 import { codesWarn } from '../messages/warn';
-import { _Map } from '../../utils/lang/maps';
 
 export function WarnLogger() {
-  return new Logger({ logLevel: 'WARN' }, new _Map(codesWarn));
+  return new Logger({ logLevel: 'WARN' }, new Map(codesWarn));
 }

package/src/logger/index.ts

@@ -2,7 +2,6 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { ILoggerOptions, ILogger } from './types';
 import { find, isObject } from '../utils/lang';
 import { LogLevel } from '../types';
-import { IMap, _Map } from '../utils/lang/maps';
 
 export const LogLevels: { [level: string]: LogLevel } = {
   DEBUG: 'DEBUG',
@@ -47,12 +46,12 @@ const defaultOptions = {
 export class Logger implements ILogger {
 
   private options: Required<ILoggerOptions>;
-  private codes: IMap<number, string>;
+  private codes: Map<number, string>;
   private logLevel: number;
 
-  constructor(options?: ILoggerOptions, codes?: IMap<number, string>) {
+  constructor(options?: ILoggerOptions, codes?: Map<number, string>) {
     this.options = objectAssign({}, defaultOptions, options);
-    this.codes = codes || new _Map();
+    this.codes = codes || new Map();
     this.logLevel = LogLevelIndexes[this.options.logLevel];
   }
 

package/src/sdkClient/clientCS.ts

@@ -5,18 +5,17 @@ import { clientAttributesDecoration } from './clientAttributesDecoration';
 
 
 /**
- * Decorator that binds a key and (optionally) a traffic type to client methods
+ * Decorator that binds a key to client methods
  *
  * @param client sync client instance
  * @param key validated split key
- * @param trafficType validated traffic type
  */
-export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
+export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey): SplitIO.ICsClient {
 
   let clientCS = clientAttributesDecoration(log, client);
 
   return objectAssign(clientCS, {
-    // In the client-side API, we bind a key to the client `getTreatment*` methods
+    // In the client-side API, we bind a key to the client `getTreatment*` and `track` methods
     getTreatment: clientCS.getTreatment.bind(clientCS, key),
     getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
     getTreatments: clientCS.getTreatments.bind(clientCS, key),
@@ -26,12 +25,10 @@ export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: Sp
     getTreatmentsByFlagSet: clientCS.getTreatmentsByFlagSet.bind(clientCS, key),
     getTreatmentsWithConfigByFlagSet: clientCS.getTreatmentsWithConfigByFlagSet.bind(clientCS, key),
 
-    // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-    track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
+    track: clientCS.track.bind(clientCS, key),
 
     // Not part of the public API. These properties are used to support other modules (e.g., Split Suite)
     isClientSide: true,
-    key,
-    trafficType
+    key
   }) as SplitIO.ICsClient;
 }

package/src/sdkClient/sdkClientMethodCS.ts

@@ -35,7 +35,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
       return mainClientInstance;
     }
 
-    // Validate the key value. The trafficType (2nd argument) is ignored
+    // Validate the key value
     const validKey = validateKey(log, key, LOG_PREFIX_CLIENT_INSTANTIATION);
     if (validKey === false) {
       throw new Error('Shared Client needs a valid key.');

package/src/sdkFactory/types.ts

@@ -95,7 +95,7 @@ export interface ISdkFactoryParams {
 
   // Sdk client method factory (ISDK::client method).
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
   // Impression observer factory.
   impressionsObserverFactory: () => IImpressionObserver

package/src/services/decorateHeaders.ts

@@ -1,8 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { _Set } from '../utils/lang/sets';
 import { ISettings } from '../types';
 
-const FORBIDDEN_HEADERS = new _Set([
+const FORBIDDEN_HEADERS = new Set([
   'splitsdkclientkey',
   'splitsdkversion',
   'splitsdkmachineip',

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,7 +1,6 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { ISet } from '../utils/lang/sets';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
@@ -18,7 +17,7 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   abstract getChangeNumber(): Promise<number>
   abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
-  abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>
+  abstract getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
 

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,7 +1,6 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { ISet } from '../utils/lang/sets';
 import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 
 /**
@@ -80,7 +79,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return false;
   }
 
-  abstract getNamesByFlagSets(flagSets: string[]): ISet<string>[]
+  abstract getNamesByFlagSets(flagSets: string[]): Set<string>[]
 
 }
 

package/src/storages/KeyBuilderCS.ts

@@ -4,7 +4,6 @@ import { KeyBuilder } from './KeyBuilder';
 export interface MySegmentsKeyBuilder {
   buildSegmentNameKey(segmentName: string): string;
   extractSegmentName(builtSegmentKeyName: string): string | undefined;
-  extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
   buildTillKey(): string;
 }
 
@@ -33,14 +32,6 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
       return builtSegmentKeyName.substr(prefix.length);
   }
 
-  // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
-  extractOldSegmentKey(builtSegmentKeyName: string) {
-    const prefix = `${this.matchingKey}.${this.prefix}.segment.`;
-
-    if (startsWith(builtSegmentKeyName, prefix))
-      return builtSegmentKeyName.substr(prefix.length);
-  }
-
   buildLastUpdatedKey() {
     return `${this.prefix}.splits.lastUpdated`;
   }
@@ -66,10 +57,6 @@ export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string):
       if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.substr(p.length);
     },
 
-    extractOldSegmentKey() {
-      return undefined;
-    },
-
     buildTillKey() {
       return `${prefix}.${matchingKey}.largeSegments.till`;
     }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -51,27 +51,7 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     return Object.keys(localStorage).reduce((accum, key) => {
       let segmentName = this.keys.extractSegmentName(key);
 
-      if (segmentName) {
-        accum.push(segmentName);
-      } else {
-        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
-        segmentName = this.keys.extractOldSegmentKey(key);
-
-        if (segmentName) { // this was an old segment key, let's clean up.
-          const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
-          try {
-            // If the new format key is not there, create it.
-            if (!localStorage.getItem(newSegmentKey)) {
-              localStorage.setItem(newSegmentKey, DEFINED);
-              // we are migrating a segment, let's track it.
-              accum.push(segmentName);
-            }
-            localStorage.removeItem(key); // we migrated the current key, let's delete it.
-          } catch (e) {
-            this.log.error(e);
-          }
-        }
-      }
+      if (segmentName) accum.push(segmentName);
 
       return accum;
     }, [] as string[]);

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -4,9 +4,9 @@ import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { ISet, _Set, setToArray } from '../../utils/lang/sets';
 import { ISettings } from '../../types';
 import { getStorageHash } from '../KeyBuilder';
+import { setToArray } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -259,12 +259,12 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     // if the filter didn't change, nothing is done
   }
 
-  getNamesByFlagSets(flagSets: string[]): ISet<string>[] {
+  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
     return flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
       const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
-      return new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+      return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
     });
   }
 
@@ -279,7 +279,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
       const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
-      const flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+      const flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
       flagSetCache.add(featureFlag.name);
 
       localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
@@ -301,7 +301,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
     if (!flagSetFromLocalStorage) return;
 
-    const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+    const flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
     flagSetCache.delete(featureFlagName);
 
     if (flagSetCache.size === 0) {

package/src/storages/inLocalStorage/index.ts

@@ -65,7 +65,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
         this.uniqueKeys?.clear();
       },
 
-      // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
+      // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
 
         return {

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -41,7 +41,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       this.uniqueKeys && this.uniqueKeys.clear();
     },
 
-    // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
+    // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
       return {
         splits: this.splits,

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -1,4 +1,3 @@
-import { ISet, _Set } from '../../utils/lang/sets';
 import { isIntegerNumber } from '../../utils/lang';
 import { ISegmentsCacheSync } from '../types';
 
@@ -7,11 +6,11 @@ import { ISegmentsCacheSync } from '../types';
  */
 export class SegmentsCacheInMemory implements ISegmentsCacheSync {
 
-  private segmentCache: Record<string, ISet<string>> = {};
+  private segmentCache: Record<string, Set<string>> = {};
   private segmentChangeNumber: Record<string, number> = {};
 
   update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
-    const keySet = this.segmentCache[name] || new _Set<string>();
+    const keySet = this.segmentCache[name] || new Set<string>();
 
     addedKeys.forEach(k => keySet.add(k));
     removedKeys.forEach(k => keySet.delete(k));
@@ -39,7 +38,7 @@ export class SegmentsCacheInMemory implements ISegmentsCacheSync {
 
   private _registerSegment(name: string) {
     if (!this.segmentCache[name]) {
-      this.segmentCache[name] = new _Set<string>();
+      this.segmentCache[name] = new Set<string>();
     }
 
     return true;

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,7 +1,6 @@
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
-import { ISet, _Set } from '../../utils/lang/sets';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -13,7 +12,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private segmentsCount: number = 0;
-  private flagSetsCache: Record<string, ISet<string>> = {};
+  private flagSetsCache: Record<string, Set<string>> = {};
 
   constructor(splitFiltersValidation?: ISplitFiltersValidation) {
     super();
@@ -103,8 +102,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return this.getChangeNumber() === -1 || this.segmentsCount > 0;
   }
 
-  getNamesByFlagSets(flagSets: string[]): ISet<string>[] {
-    return flagSets.map(flagSet => this.flagSetsCache[flagSet] || new _Set());
+  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
+    return flagSets.map(flagSet => this.flagSetsCache[flagSet] || new Set());
   }
 
   private addToFlagSets(featureFlag: ISplit) {
@@ -113,7 +112,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
       if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
 
-      if (!this.flagSetsCache[featureFlagSet]) this.flagSetsCache[featureFlagSet] = new _Set([]);
+      if (!this.flagSetsCache[featureFlagSet]) this.flagSetsCache[featureFlagSet] = new Set([]);
 
       this.flagSetsCache[featureFlagSet].add(featureFlag.name);
     });