@splitsoftware/splitio-commons 1.16.1-rc.1 → 1.16.1-rc.11

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/SplitsCacheInLocal.js

@@ -1,10 +1,9 @@
 import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { _Set, setToArray } from '../../utils/lang/sets';
 import { getStorageHash } from '../KeyBuilder';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -38,14 +37,10 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             if (split) {
                 var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
                 this._decrementCount(ttKey);
-                if (usesMatcher(split, IN_SEGMENT)) {
+                if (usesSegments(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     this._decrementCount(segmentsCountKey);
                 }
-                if (usesMatcher(split, IN_LARGE_SEGMENT)) {
-                    var segmentsCountKey = this.keys.buildSplitsWithLargeSegmentCountKey();
-                    this._decrementCount(segmentsCountKey);
-                }
             }
         }
         catch (e) {
@@ -58,16 +53,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
                 // @ts-expect-error
                 localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-                if (usesMatcher(split, IN_SEGMENT)) {
+                if (usesSegments(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     // @ts-expect-error
                     localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
                 }
-                if (usesMatcher(split, IN_LARGE_SEGMENT)) {
-                    var segmentsCountKey = this.keys.buildSplitsWithLargeSegmentCountKey();
-                    // @ts-expect-error
-                    localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
-                }
             }
         }
         catch (e) {
@@ -180,13 +170,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         var ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
         return isFiniteNumber(ttCount) && ttCount > 0;
     };
-    SplitsCacheInLocal.prototype.usesMatcher = function (matcherType) {
+    SplitsCacheInLocal.prototype.usesSegments = function () {
         // If cache hasn't been synchronized with the cloud, assume we need them.
         if (!this.hasSync)
             return true;
-        var storedCount = localStorage.getItem(matcherType === IN_SEGMENT ?
-            this.keys.buildSplitsWithSegmentCountKey() :
-            this.keys.buildSplitsWithLargeSegmentCountKey());
+        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
         if (isFiniteNumber(splitsWithSegmentsCount)) {
             return splitsWithSegmentsCount > 0;

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);

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,8 +1,7 @@
 import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
 import { _Set } from '../../utils/lang/sets';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
@@ -15,7 +14,6 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.ttCache = {};
         _this.changeNumber = -1;
         _this.segmentsCount = 0;
-        _this.largeSegmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -25,7 +23,6 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.ttCache = {};
         this.changeNumber = -1;
         this.segmentsCount = 0;
-        this.largeSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -35,11 +32,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Substract from segments count for the previous version of this Split.
-            if (usesMatcher(previousSplit, IN_SEGMENT))
+            // Subtract from segments count for the previous version of this Split
+            if (usesSegments(previousSplit))
                 this.segmentsCount--;
-            if (usesMatcher(previousSplit, IN_LARGE_SEGMENT))
-                this.largeSegmentsCount--;
         }
         if (split) {
             // Store the Split.
@@ -49,10 +44,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
-            if (usesMatcher(split, IN_SEGMENT))
+            if (usesSegments(split))
                 this.segmentsCount++;
-            if (usesMatcher(split, IN_LARGE_SEGMENT))
-                this.largeSegmentsCount++;
             return true;
         }
         else {
@@ -70,10 +63,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
                 delete this.ttCache[ttName];
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
-            if (usesMatcher(split, IN_SEGMENT))
+            if (usesSegments(split))
                 this.segmentsCount--;
-            if (usesMatcher(split, IN_LARGE_SEGMENT))
-                this.largeSegmentsCount--;
             return true;
         }
         else {
@@ -96,8 +87,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
         return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
-    SplitsCacheInMemory.prototype.usesMatcher = function (matcherType) {
-        return this.getChangeNumber() === -1 || (matcherType === IN_SEGMENT ? this.segmentsCount > 0 : this.largeSegmentsCount > 0);
+    SplitsCacheInMemory.prototype.usesSegments = function () {
+        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

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

@@ -2,20 +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) {
+export function mySegmentsFetcherFactory(fetchMemberships) {
     return function mySegmentsFetcher(userMatchingKey, noCache, 
-    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
+    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
     decorator) {
-        var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);
+        var mySegmentsPromise = fetchMemberships(userMatchingKey, noCache);
         if (decorator)
             mySegmentsPromise = decorator(mySegmentsPromise);
-        // Extract segment names
-        return mySegmentsPromise
-            .then(function (resp) { return resp.json(); })
-            .then(function (json) {
-            return json.mySegments ?
-                json.mySegments.map(function (segment) { return segment.name; }) :
-                json.myLargeSegments;
-        });
+        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

@@ -3,8 +3,7 @@ import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-import { POLLING_START, POLLING_STOP } from '../../logger/constants';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
+import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -13,74 +12,59 @@ export function pollingManagerCSFactory(params) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
-    // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
+    // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = getMatching(settings.core.key);
-    var _a = add(matchingKey, readiness, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
     function startMySegmentsSyncTasks() {
-        var splitsHaveSegments = storage.splits.usesMatcher(IN_SEGMENT);
-        var splitsHaveLargeSegments = storage.splits.usesMatcher(IN_LARGE_SEGMENT);
-        forOwn(mySegmentsSyncTasks, function (_a) {
-            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-            if (splitsHaveSegments)
-                msSyncTask.start();
-            else
-                msSyncTask.stop(); // smart pausing
-            if (mlsSyncTask) {
-                if (splitsHaveLargeSegments)
-                    mlsSyncTask.start();
-                else
-                    mlsSyncTask.stop(); // smart pausing
-            }
+        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+            mySegmentsSyncTask.start();
         });
     }
     function stopMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (_a) {
-            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-            msSyncTask.stop();
-            mlsSyncTask && mlsSyncTask.stop();
+        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+            if (mySegmentsSyncTask.isRunning())
+                mySegmentsSyncTask.stop();
         });
     }
+    // smart pausing
     readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
-        if (splitsSyncTask.isRunning())
-            startMySegmentsSyncTasks();
+        if (!splitsSyncTask.isRunning())
+            return; // noop if not doing polling
+        var splitsHaveSegments = storage.splits.usesSegments();
+        if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
+            log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
+            if (splitsHaveSegments) {
+                startMySegmentsSyncTasks();
+            }
+            else {
+                stopMySegmentsSyncTasks();
+            }
+        }
     });
     function add(matchingKey, readiness, storage) {
-        var msSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage.segments, function () { if (storage.splits.usesMatcher(IN_SEGMENT))
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED); }, settings, matchingKey, settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
-        var mlsSyncTask;
-        if (settings.sync.largeSegmentsEnabled) {
-            mlsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMyLargeSegments, storage.largeSegments, function () { if (readiness.largeSegments && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-                readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED); }, settings, matchingKey, settings.scheduler.largeSegmentsRefreshRate, 'myLargeSegmentsUpdater');
-        }
+        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
-            if (!readiness.isReady()) {
-                if (readiness.largeSegments && !storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-                    readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
-                if (!storage.splits.usesMatcher(IN_SEGMENT))
-                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-            }
+            if (!readiness.isReady() && !storage.splits.usesSegments())
+                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }
-        if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-            readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
-        else
+        if (!storage.splits.usesSegments())
             setTimeout(smartReady, 0);
-        mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
-        return {
-            msSyncTask: msSyncTask,
-            mlsSyncTask: mlsSyncTask
-        };
+        else
+            readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+        return mySegmentsSyncTask;
     }
     return {
         splitsSyncTask: splitsSyncTask,
-        segmentsSyncTask: msSyncTask,
-        largeSegmentsSyncTask: mlsSyncTask,
+        segmentsSyncTask: mySegmentsSyncTask,
         // Start periodic fetching (polling)
         start: function () {
             log.info(POLLING_START);
             splitsSyncTask.start();
-            startMySegmentsSyncTasks();
+            if (storage.splits.usesSegments())
+                startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)
         stop: function () {
@@ -94,10 +78,8 @@ export function pollingManagerCSFactory(params) {
         // fetch splits and segments
         syncAll: function () {
             var promises = [splitsSyncTask.execute()];
-            forOwn(mySegmentsSyncTasks, function (_a) {
-                var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-                promises.push(msSyncTask.execute());
-                mlsSyncTask && promises.push(mlsSyncTask.execute());
+            forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                promises.push(mySegmentsSyncTask.execute());
             });
             return Promise.all(promises);
         },

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, mySegmentsCache, notifyUpdate, settings, matchingKey, segmentsRefreshRate, NAME) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, NAME);
+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,12 +1,15 @@
 import { timeout } from '../../../utils/promise/timeout';
+import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
+import { MEMBERSHIP_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, mySegmentsCache, notifyUpdate, 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  */
@@ -18,28 +21,19 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache
     // @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 === MEMBERSHIP_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 (shouldNotifyUpdate || readyOnAlreadyExistentState) {
+        if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
-            notifyUpdate();
+            segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache) {

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, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIP_MS_UPDATE, MEMBERSHIP_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,21 +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 MY_LARGE_SEGMENTS_UPDATE:
+                case MEMBERSHIP_MS_UPDATE:
+                case MEMBERSHIP_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);