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

package/cjs/sdkFactory/index.js

@@ -19,20 +19,13 @@ var constants_3 = require("../utils/constants");
  * Modular SDK factory
  */
 function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
     var log = settings.log, impressionsMode = settings.sync.impressionsMode;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // initialization
-    var hasInit = false;
-    var initCallbacks = [];
-    function whenInit(cb) {
-        if (hasInit)
-            cb();
-        else
-            initCallbacks.push(cb);
-    }
-    var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(platform.EventEmitter, settings);
+    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+    (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
+    var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
         settings: settings,
@@ -47,7 +40,6 @@ function sdkFactory(params) {
         },
     });
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-    var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
@@ -63,11 +55,11 @@ function sdkFactory(params) {
         default:
             strategy = (0, strategyDebug_1.strategyDebugFactory)(observer);
     }
-    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -75,19 +67,8 @@ function sdkFactory(params) {
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    function init() {
-        if (hasInit)
-            return;
-        hasInit = true;
-        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-        (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
-        readiness.init();
-        uniqueKeysTracker && uniqueKeysTracker.start();
-        syncManager && syncManager.start();
-        signalListener && signalListener.start();
-        initCallbacks.forEach(function (cb) { return cb(); });
-        initCallbacks.length = 0;
-    }
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
     log.info(constants_1.NEW_FACTORY);
     // @ts-ignore
     return (0, objectAssign_1.objectAssign)({
@@ -101,9 +82,6 @@ function sdkFactory(params) {
         // Logger wrapper API
         Logger: (0, sdkLogger_1.createLoggerAPI)(log),
         settings: settings,
-        destroy: function () {
-            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
-        }
-    }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());
+    }, extraProps && extraProps(ctx));
 }
 exports.sdkFactory = sdkFactory;

package/cjs/services/decorateHeaders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decorateHeaders = void 0;
+exports.removeNonISO88591 = exports.decorateHeaders = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var sets_1 = require("../utils/lang/sets");
 var FORBIDDEN_HEADERS = new sets_1._Set([
@@ -34,3 +34,8 @@ function decorateHeaders(settings, headers) {
     return headers;
 }
 exports.decorateHeaders = decorateHeaders;
+function removeNonISO88591(input) {
+    // eslint-disable-next-line no-control-regex
+    return input.replace(/[^\x00-\xFF]/g, '');
+}
+exports.removeNonISO88591 = removeNonISO88591;

package/cjs/services/splitApi.js

@@ -54,15 +54,15 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SEGMENT));
         },
-        fetchMemberships: function (userMatchingKey, noCache, till) {
+        fetchMySegments: function (userMatchingKey, noCache) {
             /**
              * URI encoding of user keys in order to:
-             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-             *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
+             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
+             *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
-            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.MEMBERSHIPS));
+            var url = urls.sdk + "/mySegments/" + encodeURIComponent(userMatchingKey);
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.MY_SEGMENT));
         },
         /**
          * Post events.

package/cjs/services/splitHttpClient.js

@@ -4,6 +4,8 @@ exports.splitHttpClientFactory = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../logger/constants");
 var decorateHeaders_1 = require("./decorateHeaders");
+var timeout_1 = require("../utils/promise/timeout");
+var PENDING_FETCH_ERROR_TIMEOUT = 100;
 var messageNoFetch = 'Global fetch API is not available.';
 /**
  * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.
@@ -28,7 +30,7 @@ function splitHttpClientFactory(settings, _a) {
     if (ip)
         commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
-        commonHeaders['SplitSDKMachineName'] = hostname;
+        commonHeaders['SplitSDKMachineName'] = (0, decorateHeaders_1.removeNonISO88591)(hostname);
     return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
@@ -43,7 +45,8 @@ function splitHttpClientFactory(settings, _a) {
             // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
             .then(function (response) {
             if (!response.ok) {
-                return response.text().then(function (message) { return Promise.reject({ response: response, message: message }); });
+                // `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
+                return (0, timeout_1.timeout)(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(function (message) { return Promise.reject({ response: response, message: message }); }, function () { return Promise.reject({ response: response }); });
             }
             latencyTracker();
             return response;

package/cjs/storages/AbstractSegmentsCacheSync.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSegmentsCacheSync = void 0;
+/**
+ * This class provides a skeletal implementation of the ISegmentsCacheSync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractSegmentsCacheSync = /** @class */ (function () {
+    function AbstractSegmentsCacheSync() {
+    }
+    /**
+     * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
+     * For client-side synchronizer: the method is not used.
+     */
+    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
+    /**
+     * For server-side synchronizer: set the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    AbstractSegmentsCacheSync.prototype.setChangeNumber = function (name, changeNumber) { return true; };
+    /**
+     * For server-side synchronizer: get the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    AbstractSegmentsCacheSync.prototype.getChangeNumber = function (name) { return -1; };
+    /**
+     * For server-side synchronizer: the method is not used.
+     * For client-side synchronizer: reset the cache with the given list of segments.
+     */
+    AbstractSegmentsCacheSync.prototype.resetSegments = function (names) { return true; };
+    return AbstractSegmentsCacheSync;
+}());
+exports.AbstractSegmentsCacheSync = AbstractSegmentsCacheSync;

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -70,8 +70,7 @@ function usesSegments(split) {
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === constants_1.IN_SEGMENT || matcher === constants_1.IN_LARGE_SEGMENT)
+            if (matchers[j].matcherType === constants_1.IN_SEGMENT)
                 return true;
         }
     }

package/cjs/storages/KeyBuilderCS.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.myLargeSegmentsKeyBuilder = exports.KeyBuilderCS = void 0;
+exports.KeyBuilderCS = void 0;
 var tslib_1 = require("tslib");
 var lang_1 = require("../utils/lang");
 var KeyBuilder_1 = require("./KeyBuilder");
@@ -24,6 +24,10 @@ var KeyBuilderCS = /** @class */ (function (_super) {
             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
+    KeyBuilderCS.prototype.buildOldSegmentNameKey = function (segmentName) {
+        return this.matchingKey + "." + this.prefix + ".segment." + segmentName;
+    };
+    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
     KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {
         var prefix = this.matchingKey + "." + this.prefix + ".segment.";
         if ((0, lang_1.startsWith)(builtSegmentKeyName, prefix))
@@ -35,28 +39,6 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
         return this.regexSplitsCacheKey.test(key);
     };
-    KeyBuilderCS.prototype.buildTillKey = function () {
-        return this.prefix + "." + this.matchingKey + ".segments.till";
-    };
     return KeyBuilderCS;
 }(KeyBuilder_1.KeyBuilder));
 exports.KeyBuilderCS = KeyBuilderCS;
-function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
-    return {
-        buildSegmentNameKey: function (segmentName) {
-            return prefix + "." + matchingKey + ".largeSegment." + segmentName;
-        },
-        extractSegmentName: function (builtSegmentKeyName) {
-            var p = prefix + "." + matchingKey + ".largeSegment.";
-            if ((0, lang_1.startsWith)(builtSegmentKeyName, p))
-                return builtSegmentKeyName.substr(p.length);
-        },
-        extractOldSegmentKey: function () {
-            return undefined;
-        },
-        buildTillKey: function () {
-            return prefix + "." + matchingKey + ".largeSegments.till";
-        }
-    };
-}
-exports.myLargeSegmentsKeyBuilder = myLargeSegmentsKeyBuilder;

package/cjs/storages/dataLoader.js

@@ -45,7 +45,7 @@ function dataLoaderFactory(preloadedData) {
                 return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
             });
         }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+        storage.segments.resetSegments(mySegmentsData);
     };
 }
 exports.dataLoaderFactory = dataLoaderFactory;

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsCacheInLocal = void 0;
 var tslib_1 = require("tslib");
-var lang_1 = require("../../utils/lang");
-var AbstractMySegmentsCacheSync_1 = require("../AbstractMySegmentsCacheSync");
+var AbstractSegmentsCacheSync_1 = require("../AbstractSegmentsCacheSync");
 var constants_1 = require("./constants");
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(MySegmentsCacheInLocal, _super);
@@ -14,11 +13,19 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
-    MySegmentsCacheInLocal.prototype.addSegment = function (name) {
+    /**
+     * Removes list of segments from localStorage
+     * @NOTE this method is not being used at the moment.
+     */
+    MySegmentsCacheInLocal.prototype.clear = function () {
+        this.log.info(constants_1.LOG_PREFIX + 'Flushing MySegments data from localStorage');
+        // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
+        // We could optimize next sentence, since it implies iterating over all localStorage items
+        this.resetSegments([]);
+    };
+    MySegmentsCacheInLocal.prototype.addToSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) === constants_1.DEFINED)
-                return false;
             localStorage.setItem(segmentKey, constants_1.DEFINED);
             return true;
         }
@@ -27,11 +34,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             return false;
         }
     };
-    MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
+    MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) !== constants_1.DEFINED)
-                return false;
             localStorage.removeItem(segmentKey);
             return true;
         }
@@ -43,22 +48,30 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === constants_1.DEFINED;
     };
-    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     *
+     * @param {string[]} segmentNames list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    MySegmentsCacheInLocal.prototype.resetSegments = function (names) {
         var _this = this;
+        var isDiff = false;
+        var index;
         // Scan current values from localStorage
-        return Object.keys(localStorage).reduce(function (accum, key) {
+        var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
             var 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
+                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
                 segmentName = _this.keys.extractOldSegmentKey(key);
                 if (segmentName) { // this was an old segment key, let's clean up.
                     var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
                     try {
                         // If the new format key is not there, create it.
-                        if (!localStorage.getItem(newSegmentKey)) {
+                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
                             localStorage.setItem(newSegmentKey, constants_1.DEFINED);
                             // we are migrating a segment, let's track it.
                             accum.push(segmentName);
@@ -72,30 +85,40 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             }
             return accum;
         }, []);
-    };
-    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
-        return 1;
-    };
-    MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            if (changeNumber)
-                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-            else
-                localStorage.removeItem(this.keys.buildTillKey());
+        // Extreme fast => everything is empty
+        if (names.length === 0 && storedSegmentNames.length === names.length)
+            return isDiff;
+        // Quick path
+        if (storedSegmentNames.length !== names.length) {
+            isDiff = true;
+            storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
+            names.forEach(function (name) { return _this.addToSegment(name); });
         }
-        catch (e) {
-            this.log.error(e);
+        else {
+            // Slowest path => we need to find at least 1 difference because
+            for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
+                // TODO: why empty statement?
+            }
+            if (index < names.length) {
+                isDiff = true;
+                storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
+                names.forEach(function (name) { return _this.addToSegment(name); });
+            }
         }
+        return isDiff;
     };
-    MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = localStorage.getItem(this.keys.buildTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(value) ? n : value;
-        }
-        return n;
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
+        var _this = this;
+        return Object.keys(localStorage).reduce(function (accum, key) {
+            var segmentName = _this.keys.extractSegmentName(key);
+            if (segmentName)
+                accum.push(segmentName);
+            return accum;
+        }, []);
+    };
+    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
+        return 1;
     };
     return MySegmentsCacheInLocal;
-}(AbstractMySegmentsCacheSync_1.AbstractMySegmentsCacheSync));
+}(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));
 exports.MySegmentsCacheInLocal = MySegmentsCacheInLocal;

package/cjs/storages/inLocalStorage/index.js

@@ -36,11 +36,9 @@ function InLocalStorage(options) {
         var expirationTimestamp = Date.now() - browser_1.DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
-        var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey));
         return {
             splits: splits,
             segments: segments,
-            largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: impressionsMode !== constants_2.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
@@ -50,7 +48,6 @@ function InLocalStorage(options) {
                 var _a;
                 this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
                 this.segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-                this.largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
@@ -58,10 +55,10 @@ function InLocalStorage(options) {
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
+                var childKeysBuilder = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
                 return {
                     splits: this.splits,
-                    segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey)),
-                    largeSegments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey)),
+                    segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, childKeysBuilder),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,
@@ -69,7 +66,6 @@ function InLocalStorage(options) {
                     destroy: function () {
                         this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
                         this.segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-                        this.largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
                     }
                 };
             },

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -18,11 +18,9 @@ function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-    var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
         segments: segments,
-        largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
@@ -32,7 +30,6 @@ function InMemoryStorageCSFactory(params) {
         destroy: function () {
             this.splits.clear();
             this.segments.clear();
-            this.largeSegments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
@@ -43,7 +40,6 @@ function InMemoryStorageCSFactory(params) {
             return {
                 splits: this.splits,
                 segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -52,13 +48,12 @@ function InMemoryStorageCSFactory(params) {
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
-                    this.largeSegments.clear();
                 }
             };
         },
     };
     // @TODO revisit storage logic in localhost mode
-    // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
+    // No tracking data in localhost mode to avoid memory leaks
     if (params.settings.mode === constants_1.LOCALHOST_MODE) {
         var noopTrack = function () { return true; };
         storage.impressions.track = noopTrack;

package/cjs/storages/inMemory/MySegmentsCacheInMemory.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsCacheInMemory = void 0;
 var tslib_1 = require("tslib");
-var AbstractMySegmentsCacheSync_1 = require("../AbstractMySegmentsCacheSync");
+var AbstractSegmentsCacheSync_1 = require("../AbstractSegmentsCacheSync");
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
@@ -14,26 +14,57 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
-    MySegmentsCacheInMemory.prototype.addSegment = function (name) {
-        if (this.segmentCache[name])
-            return false;
+    MySegmentsCacheInMemory.prototype.clear = function () {
+        this.segmentCache = {};
+    };
+    MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
         this.segmentCache[name] = true;
         return true;
     };
-    MySegmentsCacheInMemory.prototype.removeSegment = function (name) {
-        if (!this.segmentCache[name])
-            return false;
+    MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
         delete this.segmentCache[name];
         return true;
     };
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    MySegmentsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
-        this.cn = changeNumber;
-    };
-    MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.cn || -1;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     * @NOTE based on the way we use segments in the browser, this way is the best option
+     *
+     * @param {string[]} names list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    MySegmentsCacheInMemory.prototype.resetSegments = function (names) {
+        var _this = this;
+        var isDiff = false;
+        var index;
+        var storedSegmentKeys = Object.keys(this.segmentCache);
+        // Extreme fast => everything is empty
+        if (names.length === 0 && storedSegmentKeys.length === names.length)
+            return isDiff;
+        // Quick path
+        if (storedSegmentKeys.length !== names.length) {
+            isDiff = true;
+            this.segmentCache = {};
+            names.forEach(function (s) {
+                _this.addToSegment(s);
+            });
+        }
+        else {
+            // Slowest path => we need to find at least 1 difference because
+            for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
+                // TODO: why empty statement?
+            }
+            if (index < names.length) {
+                isDiff = true;
+                this.segmentCache = {};
+                names.forEach(function (s) {
+                    _this.addToSegment(s);
+                });
+            }
+        }
+        return isDiff;
     };
     MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
         return Object.keys(this.segmentCache);
@@ -42,5 +73,5 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         return 1;
     };
     return MySegmentsCacheInMemory;
-}(AbstractMySegmentsCacheSync_1.AbstractMySegmentsCacheSync));
+}(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));
 exports.MySegmentsCacheInMemory = MySegmentsCacheInMemory;

package/cjs/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,23 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentsCacheInMemory = void 0;
+var tslib_1 = require("tslib");
+var AbstractSegmentsCacheSync_1 = require("../AbstractSegmentsCacheSync");
 var sets_1 = require("../../utils/lang/sets");
 var lang_1 = require("../../utils/lang");
 /**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
-var SegmentsCacheInMemory = /** @class */ (function () {
+var SegmentsCacheInMemory = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(SegmentsCacheInMemory, _super);
     function SegmentsCacheInMemory() {
-        this.segmentCache = {};
-        this.segmentChangeNumber = {};
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.segmentCache = {};
+        _this.segmentChangeNumber = {};
+        return _this;
     }
-    SegmentsCacheInMemory.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
-        var keySet = this.segmentCache[name] || new sets_1._Set();
-        addedKeys.forEach(function (k) { return keySet.add(k); });
-        removedKeys.forEach(function (k) { return keySet.delete(k); });
+    SegmentsCacheInMemory.prototype.addToSegment = function (name, segmentKeys) {
+        var values = this.segmentCache[name];
+        var keySet = values ? values : new sets_1._Set();
+        segmentKeys.forEach(function (k) { return keySet.add(k); });
         this.segmentCache[name] = keySet;
-        this.segmentChangeNumber[name] = changeNumber;
-        return addedKeys.length > 0 || removedKeys.length > 0;
+        return true;
+    };
+    SegmentsCacheInMemory.prototype.removeFromSegment = function (name, segmentKeys) {
+        var values = this.segmentCache[name];
+        var keySet = values ? values : new sets_1._Set();
+        segmentKeys.forEach(function (k) { return keySet.delete(k); });
+        this.segmentCache[name] = keySet;
+        return true;
     };
     SegmentsCacheInMemory.prototype.isInSegment = function (name, key) {
         var segmentValues = this.segmentCache[name];
@@ -51,12 +63,14 @@ var SegmentsCacheInMemory = /** @class */ (function () {
             return acum + _this.segmentCache[segmentName].size;
         }, 0);
     };
+    SegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
+        this.segmentChangeNumber[name] = changeNumber;
+        return true;
+    };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
-        return (0, lang_1.isIntegerNumber)(value) ? value : -1;
+        return (0, lang_1.isIntegerNumber)(value) ? value : undefined;
     };
-    // No-op. Not used in server-side
-    SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };
     return SegmentsCacheInMemory;
-}());
+}(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));
 exports.SegmentsCacheInMemory = SegmentsCacheInMemory;