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

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -13,7 +13,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.splitsWithSegmentsCount = 0;
+        _this.segmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -22,7 +22,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsCache = {};
         this.ttCache = {};
         this.changeNumber = -1;
-        this.splitsWithSegmentsCount = 0;
+        this.segmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -32,9 +32,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
-                this.splitsWithSegmentsCount--;
-            }
+            // Subtract from segments count for the previous version of this Split
+            if (usesSegments(previousSplit))
+                this.segmentsCount--;
         }
         if (split) {
             // Store the Split.
@@ -45,7 +45,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
             if (usesSegments(split))
-                this.splitsWithSegmentsCount++;
+                this.segmentsCount++;
             return true;
         }
         else {
@@ -64,7 +64,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
             if (usesSegments(split))
-                this.splitsWithSegmentsCount--;
+                this.segmentsCount--;
             return true;
         }
         else {
@@ -88,7 +88,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
     SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
+        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -18,9 +18,10 @@ export function shouldRecordTelemetry(_a) {
     return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments) {
+    function TelemetryCacheInMemory(splits, segments, largeSegments) {
         this.splits = splits;
         this.segments = segments;
+        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -36,10 +37,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {
-            sp: 0,
-            ms: 0
-        };
+        this.updatesFromSSE = {};
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -59,6 +57,8 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
+            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
+            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(QUEUED),
             eD: this.getEventStats(DROPPED),
@@ -190,14 +190,11 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {
-            sp: 0,
-            ms: 0,
-        };
+        this.updatesFromSSE = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type]++;
+        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
         this.e = false;
     };
     return TelemetryCacheInMemory;

package/esm/storages/pluggable/inMemoryWrapper.js

@@ -5,7 +5,7 @@ import { setToArray, _Set } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

package/esm/sync/polling/fetchers/mySegmentsFetcher.js

@@ -2,16 +2,13 @@
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export function mySegmentsFetcherFactory(fetchMySegments) {
-    return function mySegmentsFetcher(userMatchingKey, noCache, 
-    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
+export function mySegmentsFetcherFactory(fetchMemberships) {
+    return function mySegmentsFetcher(userMatchingKey, noCache, till, 
+    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
     decorator) {
-        var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);
+        var mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
         if (decorator)
             mySegmentsPromise = decorator(mySegmentsPromise);
-        // Extract segment names
-        return mySegmentsPromise
-            .then(function (resp) { return resp.json(); })
-            .then(function (json) { return json.mySegments.map(function (segment) { return segment.name; }); });
+        return mySegmentsPromise.then(function (resp) { return resp.json(); });
     };
 }

package/esm/sync/polling/fetchers/segmentChangesFetcher.js

@@ -20,7 +20,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache, targetTil
  */
 export function segmentChangesFetcherFactory(fetchSegmentChanges) {
     return function segmentChangesFetcher(since, segmentName, noCache, till, 
-    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
+    // Optional decorator for `fetchSegmentChanges` promise, such as timeout or time tracker
     decorator) {
         var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
         if (decorator)

package/esm/sync/polling/pollingManagerCS.js

@@ -43,7 +43,7 @@ export function pollingManagerCSFactory(params) {
         }
     });
     function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
+        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
             if (!readiness.isReady() && !storage.splits.usesSegments())

package/esm/sync/polling/syncTasks/mySegmentsSyncTask.js

@@ -4,6 +4,6 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+export function mySegmentsSyncTaskFactory(fetchMemberships, storage, readiness, settings, matchingKey) {
+    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMemberships), storage, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }

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

@@ -1,13 +1,15 @@
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
+import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+    var splits = storage.splits, segments = storage.segments, largeSegments = storage.largeSegments;
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -19,36 +21,27 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        if (Array.isArray(segmentsData)) {
-            // Update the list of segment names available
-            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+        if (segmentsData.type !== undefined) {
+            shouldNotifyUpdate = segmentsData.type === MEMBERSHIPS_LS_UPDATE ?
+                largeSegments.resetSegments(segmentsData) :
+                segments.resetSegments(segmentsData);
         }
         else {
-            // Add/Delete the segment
-            var name_1 = segmentsData.name, add = segmentsData.add;
-            if (mySegmentsCache.isInSegment(name_1) !== add) {
-                shouldNotifyUpdate = true;
-                if (add)
-                    mySegmentsCache.addToSegment(name_1);
-                else
-                    mySegmentsCache.removeFromSegment(name_1);
-            }
-            else {
-                shouldNotifyUpdate = false;
-            }
+            shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
+            shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
         // Notify update if required
-        if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }
     }
-    function _mySegmentsUpdater(retry, segmentsData, noCache) {
+    function _mySegmentsUpdater(retry, segmentsData, noCache, till) {
         var updaterPromise = segmentsData ?
             // If segmentsData is provided, there is no need to fetch mySegments
             new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
-            mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(function (segments) {
+            mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
                 startingUp = false;
                 updateSegments(segments);
@@ -75,8 +68,9 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
      *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
      *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
      * @param {boolean | undefined} noCache true to revalidate data to fetch
+     * @param {boolean | undefined} till query param to bypass CDN requests
      */
-    return function mySegmentsUpdater(segmentsData, noCache) {
-        return _mySegmentsUpdater(0, segmentsData, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache, till) {
+        return _mySegmentsUpdater(0, segmentsData, noCache, till);
     };
 }

package/esm/sync/streaming/AuthClient/index.js

@@ -10,7 +10,7 @@ import { hash } from '../../../utils/murmur3/murmur3';
 export function authenticateFactory(fetchAuth) {
     /**
      * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-     * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
+     * @param {string[] | undefined} userKeys set of user Keys to track membership updates. It is undefined for server-side API.
      */
     return function authenticate(userKeys) {
         return fetchAuth(userKeys)

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 /**
@@ -65,20 +65,18 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             }
             var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
             log.debug(STREAMING_NEW_MESSAGE, [data]);
-            // we only handle update events if streaming is up.
+            // we only handle update events if streaming is up
             if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
                 return;
             switch (parsedData.type) {
                 /* update events */
                 case SPLIT_UPDATE:
                 case SEGMENT_UPDATE:
-                case MY_SEGMENTS_UPDATE_V2:
+                case MEMBERSHIPS_MS_UPDATE:
+                case MEMBERSHIPS_LS_UPDATE:
                 case SPLIT_KILL:
                     pushEmitter.emit(parsedData.type, parsedData);
                     break;
-                case MY_SEGMENTS_UPDATE:
-                    pushEmitter.emit(parsedData.type, parsedData, channel);
-                    break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case OCCUPANCY:
                     notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);

package/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -1,61 +1,120 @@
 import { Backoff } from '../../../utils/Backoff';
-import { MY_SEGMENT } from '../../../utils/constants';
+import { MEMBERSHIPS } from '../../../utils/constants';
+import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
+import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
-    var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-    var currentChangeNumber = -1;
-    var handleNewEvent = false;
-    var isHandlingEvent;
-    var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-    var backoff = new Backoff(__handleMySegmentsUpdateCall);
-    function __handleMySegmentsUpdateCall() {
-        isHandlingEvent = true;
-        if (maxChangeNumber > currentChangeNumber) {
-            handleNewEvent = false;
-            var currentMaxChangeNumber_1 = maxChangeNumber;
-            // fetch mySegments revalidating data if cached
-            mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
-                if (!isHandlingEvent)
-                    return; // halt if `stop` has been called
-                if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-                    if (_segmentsData)
-                        telemetryTracker.trackUpdatesFromSSE(MY_SEGMENT);
-                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
-                }
-                if (handleNewEvent) {
-                    __handleMySegmentsUpdateCall();
-                }
-                else {
-                    backoff.scheduleCall();
-                }
-            });
-        }
-        else {
-            isHandlingEvent = false;
+export function MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker) {
+    var _a;
+    var _delay;
+    var _delayTimeoutID;
+    function createUpdateWorker(mySegmentsCache) {
+        var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+        var currentChangeNumber = -1;
+        var handleNewEvent = false;
+        var isHandlingEvent;
+        var cdnBypass;
+        var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+        var backoff = new Backoff(__handleMySegmentsUpdateCall);
+        function __handleMySegmentsUpdateCall() {
+            isHandlingEvent = true;
+            if (maxChangeNumber > Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber())) {
+                handleNewEvent = false;
+                var currentMaxChangeNumber_1 = maxChangeNumber;
+                // fetch mySegments revalidating data if cached
+                var syncTask = _delay ?
+                    new Promise(function (res) {
+                        _delayTimeoutID = setTimeout(function () {
+                            _delay = undefined;
+                            mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined).then(res);
+                        }, _delay);
+                    }) :
+                    mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined);
+                syncTask.then(function (result) {
+                    if (!isHandlingEvent)
+                        return; // halt if `stop` has been called
+                    if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, `mySegmentsCache.getChangeNumber` can be -1, since `/memberships` change number is optional
+                        var storageChangeNumber = mySegmentsCache.getChangeNumber();
+                        currentChangeNumber = storageChangeNumber > -1 ?
+                            storageChangeNumber :
+                            Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                    }
+                    if (handleNewEvent) {
+                        __handleMySegmentsUpdateCall();
+                    }
+                    else {
+                        if (_segmentsData)
+                            telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
+                        var attempts = backoff.attempts + 1;
+                        if (maxChangeNumber <= currentChangeNumber) {
+                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            isHandlingEvent = false;
+                            return;
+                        }
+                        if (attempts < FETCH_BACKOFF_MAX_RETRIES) {
+                            backoff.scheduleCall();
+                            return;
+                        }
+                        if (cdnBypass) {
+                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            isHandlingEvent = false;
+                        }
+                        else {
+                            backoff.reset();
+                            cdnBypass = true;
+                            __handleMySegmentsUpdateCall();
+                        }
+                    }
+                });
+            }
+            else {
+                isHandlingEvent = false;
+            }
         }
+        return {
+            /**
+             * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
+             *
+             * @param changeNumber change number of the notification
+             * @param segmentsData data for KeyList or SegmentRemoval instant updates
+             * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
+             */
+            put: function (mySegmentsData, payload, delay) {
+                var type = mySegmentsData.type, cn = mySegmentsData.cn;
+                // Discard event if it is outdated or there is a pending fetch request (_delay is set), but update target change number
+                if (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber)
+                    return;
+                maxChangeNumber = cn;
+                if (_delay)
+                    return;
+                handleNewEvent = true;
+                cdnBypass = false;
+                _segmentsData = payload && { type: type, cn: cn, added: payload.added, removed: payload.removed };
+                _delay = delay;
+                if (backoff.timeoutID || !isHandlingEvent)
+                    __handleMySegmentsUpdateCall();
+                backoff.reset();
+            },
+            stop: function () {
+                clearTimeout(_delayTimeoutID);
+                _delay = undefined;
+                isHandlingEvent = false;
+                backoff.reset();
+            }
+        };
     }
+    var updateWorkers = (_a = {},
+        _a[MEMBERSHIPS_MS_UPDATE] = createUpdateWorker(storage.segments),
+        _a[MEMBERSHIPS_LS_UPDATE] = createUpdateWorker(storage.largeSegments),
+        _a);
     return {
-        /**
-         * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
-         *
-         * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-         * @param {SegmentsData | undefined} segmentsData might be undefined
-         */
-        put: function (changeNumber, segmentsData) {
-            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
-                return;
-            maxChangeNumber = changeNumber;
-            handleNewEvent = true;
-            _segmentsData = segmentsData;
-            if (backoff.timeoutID || !isHandlingEvent)
-                __handleMySegmentsUpdateCall();
-            backoff.reset();
+        put: function (mySegmentsData, payload, delay) {
+            updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
         },
         stop: function () {
-            isHandlingEvent = false;
-            backoff.reset();
+            updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
+            updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
         }
     };
 }

package/esm/sync/streaming/constants.js

@@ -22,8 +22,8 @@ export var PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
  */
 export var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 // Update-type push notifications, handled by NotificationProcessor
-export var MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-export var MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export var MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
+export var MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';

package/esm/sync/streaming/parseUtils.js

@@ -1,5 +1,6 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
+import { hash } from '../../utils/murmur3/murmur3';
 var GZIP = 1;
 var ZLIB = 2;
 function Uint8ArrayToString(myUint8Arr) {
@@ -74,14 +75,17 @@ export function isInBitmap(bitmap, hash64hex) {
 }
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
 export function parseFFUpdatePayload(compression, data) {
-    var avoidPrecisionLoss = false;
-    if (compression > 0)
-        return parseKeyList(data, compression, avoidPrecisionLoss);
-    else
-        return JSON.parse(decodeFromBase64(data));
+    return compression > 0 ?
+        parseKeyList(data, compression, false) :
+        JSON.parse(decodeFromBase64(data));
+}
+var DEFAULT_MAX_INTERVAL = 60000;
+export function getDelay(parsedData, matchingKey) {
+    if (parsedData.h === 0)
+        return 0;
+    var interval = parsedData.i || DEFAULT_MAX_INTERVAL;
+    var seed = parsedData.s || 0;
+    return hash(matchingKey, seed) % interval;
 }