@splitsoftware/splitio-commons 1.17.0 → 1.17.1-rc.1

package/esm/sdkClient/sdkClientMethod.js

@@ -1,11 +1,13 @@
 import { sdkClientFactory } from './sdkClient';
 import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 /**
- * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
+ * Factory of client method for server-side SDKs
  */
 export function sdkClientMethodFactory(params) {
     var log = params.settings.log;
     var clientInstance = sdkClientFactory(params);
+    // Only one client in server-side without bound key
+    params.clients[''] = clientInstance;
     return function client() {
         if (arguments.length > 0) {
             throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');

package/esm/sdkClient/sdkClientMethodCS.js

@@ -5,22 +5,18 @@ import { sdkClientFactory } from './sdkClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
-function buildInstanceId(key) {
-    // @ts-ignore
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-";
-}
+import { buildInstanceId } from './identity';
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params) {
-    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, readyTimeout = _a.startup.readyTimeout, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
     // Cache instances created per factory.
-    var clientInstances = {};
-    clientInstances[defaultInstanceId] = mainClientInstance;
+    clients[defaultInstanceId] = mainClientInstance;
     return function client(key) {
         if (key === undefined) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
@@ -32,9 +28,9 @@ export function sdkClientMethodCSFactory(params) {
             throw new Error('Shared Client needs a valid key.');
         }
         var instanceId = buildInstanceId(validKey);
-        if (!clientInstances[instanceId]) {
+        if (!clients[instanceId]) {
             var matchingKey = getMatching(validKey);
-            var sharedSdkReadiness_1 = sdkReadinessManager.shared(readyTimeout);
+            var sharedSdkReadiness_1 = sdkReadinessManager.shared();
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
                 if (err) {
                     sharedSdkReadiness_1.readinessManager.timeout();
@@ -51,11 +47,10 @@ export function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
+            clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined, // only the main client "destroy" method stops the signal listener
             }), true), validKey);
             sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
@@ -63,6 +58,6 @@ export function sdkClientMethodCSFactory(params) {
         else {
             log.debug(RETRIEVE_CLIENT_EXISTING);
         }
-        return clientInstances[instanceId];
+        return clients[instanceId];
     };
 }

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -6,23 +6,19 @@ import { sdkClientFactory } from './sdkClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
-function buildInstanceId(key, trafficType) {
-    // @ts-ignore
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType !== undefined ? trafficType : '');
-}
+import { buildInstanceId } from './identity';
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
  * where clients can have a bound TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params) {
-    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, readyTimeout = _a.startup.readyTimeout, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key, trafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
     // Cache instances created per factory.
-    var clientInstances = {};
-    clientInstances[defaultInstanceId] = mainClientInstance;
+    clients[defaultInstanceId] = mainClientInstance;
     return function client(key, trafficType) {
         if (key === undefined) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
@@ -41,9 +37,9 @@ export function sdkClientMethodCSFactory(params) {
             }
         }
         var instanceId = buildInstanceId(validKey, validTrafficType);
-        if (!clientInstances[instanceId]) {
+        if (!clients[instanceId]) {
             var matchingKey = getMatching(validKey);
-            var sharedSdkReadiness_1 = sdkReadinessManager.shared(readyTimeout);
+            var sharedSdkReadiness_1 = sdkReadinessManager.shared();
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
                 if (err) {
                     sharedSdkReadiness_1.readinessManager.timeout();
@@ -60,11 +56,10 @@ export function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
+            clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined, // only the main client "destroy" method stops the signal listener
             }), true), validKey, validTrafficType);
             sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
@@ -72,6 +67,6 @@ export function sdkClientMethodCSFactory(params) {
         else {
             log.debug(RETRIEVE_CLIENT_EXISTING);
         }
-        return clientInstances[instanceId];
+        return clients[instanceId];
     };
 }

package/esm/sdkFactory/index.js

@@ -22,7 +22,7 @@ export function sdkFactory(params) {
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
     // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
     validateAndTrackApiKey(log, settings.core.authorizationKey);
-    var sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
+    var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
         settings: settings,
@@ -37,6 +37,7 @@ export function sdkFactory(params) {
         },
     });
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
@@ -56,7 +57,7 @@ export function sdkFactory(params) {
     var eventTracker = 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 = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    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 syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -79,5 +80,8 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(log),
         settings: settings,
+        destroy: function () {
+            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
+        }
     }, extraProps && extraProps(ctx));
 }

package/esm/services/splitApi.js

@@ -1,6 +1,6 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
@@ -51,15 +51,15 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
         },
-        fetchMySegments: function (userMatchingKey, noCache) {
+        fetchMemberships: function (userMatchingKey, noCache, till) {
             /**
              * URI encoding of user keys in order to:
-             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
-             *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
+             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
+             *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
-            var url = urls.sdk + "/mySegments/" + encodeURIComponent(userMatchingKey);
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
+            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
         },
         /**
          * Post events.

package/esm/storages/AbstractSegmentsCacheSync.js

@@ -6,25 +6,54 @@ 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.
+     * clear the cache.
      */
-    AbstractSegmentsCacheSync.prototype.setChangeNumber = function (name, changeNumber) { return true; };
+    AbstractSegmentsCacheSync.prototype.clear = function () {
+        this.resetSegments({});
+    };
     /**
-     * For server-side synchronizer: get the change number of `name` segment.
+     * 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.getChangeNumber = function (name) { return -1; };
+    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
     /**
      * For server-side synchronizer: the method is not used.
-     * For client-side synchronizer: reset the cache with the given list of segments.
+     * For client-side synchronizer: it resets or updates the cache.
      */
-    AbstractSegmentsCacheSync.prototype.resetSegments = function (names) { return true; };
+    AbstractSegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
+        var _this = this;
+        this.setChangeNumber(undefined, segmentsData.cn);
+        var _a = segmentsData, added = _a.added, removed = _a.removed;
+        if (added && removed) {
+            var isDiff_1 = false;
+            added.forEach(function (segment) {
+                isDiff_1 = _this.addToSegment(segment) || isDiff_1;
+            });
+            removed.forEach(function (segment) {
+                isDiff_1 = _this.removeFromSegment(segment) || isDiff_1;
+            });
+            return isDiff_1;
+        }
+        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+        var storedSegmentKeys = this.getRegisteredSegments().sort();
+        // Extreme fast => everything is empty
+        if (!names.length && !storedSegmentKeys.length)
+            return false;
+        var index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+            index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length)
+            return false;
+        // Slowest path => add and/or remove segments
+        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeFromSegment(storedSegmentKeys[removeIndex]);
+        }
+        for (var addIndex = index; addIndex < names.length; addIndex++) {
+            this.addToSegment(names[addIndex]);
+        }
+        return true;
+    };
     return AbstractSegmentsCacheSync;
 }());
 export { AbstractSegmentsCacheSync };

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IN_SEGMENT } from '../utils/constants';
+import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -67,7 +67,8 @@ export 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++) {
-            if (matchers[j].matcherType === IN_SEGMENT)
+            var matcher = matchers[j].matcherType;
+            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
                 return true;
         }
     }

package/esm/storages/KeyBuilderCS.js

@@ -21,10 +21,6 @@ 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 (startsWith(builtSegmentKeyName, prefix))
@@ -36,6 +32,27 @@ 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));
 export { KeyBuilderCS };
+export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
+    return {
+        buildSegmentNameKey: function (segmentName) {
+            return prefix + "." + matchingKey + ".largeSegment." + segmentName;
+        },
+        extractSegmentName: function (builtSegmentKeyName) {
+            var p = prefix + "." + matchingKey + ".largeSegment.";
+            if (startsWith(builtSegmentKeyName, p))
+                return builtSegmentKeyName.substr(p.length);
+        },
+        extractOldSegmentKey: function () {
+            return undefined;
+        },
+        buildTillKey: function () {
+            return prefix + "." + matchingKey + ".largeSegments.till";
+        }
+    };
+}

package/esm/storages/dataLoader.js

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

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -1,4 +1,5 @@
 import { __extends } from "tslib";
+import { isNaNNumber } from '../../utils/lang';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
@@ -10,19 +11,11 @@ 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
     }
-    /**
-     * Removes list of segments from localStorage
-     * @NOTE this method is not being used at the moment.
-     */
-    MySegmentsCacheInLocal.prototype.clear = function () {
-        this.log.info(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) === DEFINED)
+                return false;
             localStorage.setItem(segmentKey, DEFINED);
             return true;
         }
@@ -34,6 +27,8 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
+            if (localStorage.getItem(segmentKey) !== DEFINED)
+                return false;
             localStorage.removeItem(segmentKey);
             return true;
         }
@@ -45,30 +40,22 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
     };
-    /**
-     * 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) {
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
         var _this = this;
-        var isDiff = false;
-        var index;
         // Scan current values from localStorage
-        var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
+        return 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 and reuse `getRegisteredSegments` method.
+                // @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.
                     var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
                     try {
                         // If the new format key is not there, create it.
-                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+                        if (!localStorage.getItem(newSegmentKey)) {
                             localStorage.setItem(newSegmentKey, DEFINED);
                             // we are migrating a segment, let's track it.
                             accum.push(segmentName);
@@ -82,40 +69,30 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             }
             return accum;
         }, []);
-        // 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); });
-        }
-        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.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;
     };
+    MySegmentsCacheInLocal.prototype.setChangeNumber = function (name, changeNumber) {
+        try {
+            if (changeNumber)
+                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+            else
+                localStorage.removeItem(this.keys.buildTillKey());
+        }
+        catch (e) {
+            this.log.error(e);
+        }
+    };
+    MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
+        var n = -1;
+        var value = localStorage.getItem(this.keys.buildTillKey());
+        if (value !== null) {
+            value = parseInt(value, 10);
+            return isNaNNumber(value) ? n : value;
+        }
+        return n;
+    };
     return MySegmentsCacheInLocal;
 }(AbstractSegmentsCacheSync));
 export { MySegmentsCacheInLocal };

package/esm/storages/inLocalStorage/index.js

@@ -2,7 +2,7 @@ import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS } from '../KeyBuilderCS';
+import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -33,9 +33,11 @@ export function InLocalStorage(options) {
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
+        var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
         return {
             splits: splits,
             segments: segments,
+            largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory(eventsQueueSize),
@@ -45,6 +47,7 @@ export function InLocalStorage(options) {
                 var _a;
                 this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                 this.segments = new MySegmentsCacheInMemory();
+                this.largeSegments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
@@ -52,10 +55,10 @@ export 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(prefix, matchingKey);
                 return {
                     splits: this.splits,
-                    segments: new MySegmentsCacheInLocal(log, childKeysBuilder),
+                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
+                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,
@@ -63,6 +66,7 @@ export function InLocalStorage(options) {
                     destroy: function () {
                         this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                         this.segments = new MySegmentsCacheInMemory();
+                        this.largeSegments = new MySegmentsCacheInMemory();
                     }
                 };
             },

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -15,9 +15,11 @@ export 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(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
+    var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
         segments: segments,
+        largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(eventsQueueSize),
@@ -27,6 +29,7 @@ export 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();
@@ -37,6 +40,7 @@ export function InMemoryStorageCSFactory(params) {
             return {
                 splits: this.splits,
                 segments: new MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -45,6 +49,7 @@ export function InMemoryStorageCSFactory(params) {
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
+                    this.largeSegments.clear();
                 }
             };
         },

package/esm/storages/inMemory/MySegmentsCacheInMemory.js

@@ -11,57 +11,26 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
-    MySegmentsCacheInMemory.prototype.clear = function () {
-        this.segmentCache = {};
-    };
     MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
+        if (this.segmentCache[name])
+            return false;
         this.segmentCache[name] = true;
         return true;
     };
     MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
+        if (!this.segmentCache[name])
+            return false;
         delete this.segmentCache[name];
         return true;
     };
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    /**
-     * 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.setChangeNumber = function (name, changeNumber) {
+        this.cn = changeNumber;
+    };
+    MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
+        return this.cn || -1;
     };
     MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
         return Object.keys(this.segmentCache);