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

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, MY_LARGE_SEGMENT } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
@@ -51,20 +51,16 @@ 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) {
             /**
              * 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);
+            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey);
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
         },
-        fetchMyLargeSegments: function (userMatchingKey, noCache) {
-            var url = urls.sdk + "/myLargeSegments/" + encodeURIComponent(userMatchingKey);
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_LARGE_SEGMENT));
-        },
         /**
          * Post events.
          *

package/esm/storages/AbstractSegmentsCacheSync.js

@@ -15,16 +15,11 @@ var AbstractSegmentsCacheSync = /** @class */ (function () {
      * For client-side synchronizer: the method is not used.
      */
     AbstractSegmentsCacheSync.prototype.setChangeNumber = function (name, changeNumber) { return true; };
-    /**
-     * For server-side synchronizer: get the change number of `name` segment.
-     * For client-side synchronizer: the method is not used.
-     */
-    AbstractSegmentsCacheSync.prototype.getChangeNumber = function (name) { return -1; };
     /**
      * For server-side synchronizer: the method is not used.
      * For client-side synchronizer: reset the cache with the given list of segments.
      */
-    AbstractSegmentsCacheSync.prototype.resetSegments = function (names) { return true; };
+    AbstractSegmentsCacheSync.prototype.resetSegments = function (names, changeNumber) { return true; };
     return AbstractSegmentsCacheSync;
 }());
 export { AbstractSegmentsCacheSync };

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -6,9 +6,9 @@ import { objectAssign } from '../utils/lang/objectAssign';
 var AbstractSplitsCacheAsync = /** @class */ (function () {
     function AbstractSplitsCacheAsync() {
     }
-    // @TODO revisit segment-related methods ('usesMatcher', 'getRegisteredSegments', 'registerSegments')
+    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
     // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-    AbstractSplitsCacheAsync.prototype.usesMatcher = function () {
+    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
         return Promise.resolve(true);
     };
     /**

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,4 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+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.
@@ -59,14 +60,15 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
 export { AbstractSplitsCacheSync };
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesMatcher` method
+ * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
  */
-export function usesMatcher(split, matcherType) {
+export function usesSegments(split) {
     var conditions = split.conditions || [];
     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 === matcherType)
+            var matcher = matchers[j].matcherType;
+            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
                 return true;
         }
     }

package/esm/storages/KeyBuilder.js

@@ -36,9 +36,6 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildSplitsWithSegmentCountKey = function () {
         return this.prefix + ".splits.usingSegments";
     };
-    KeyBuilder.prototype.buildSplitsWithLargeSegmentCountKey = function () {
-        return this.prefix + ".splits.usingLargeSegments";
-    };
     KeyBuilder.prototype.buildSegmentNameKey = function (segmentName) {
         return this.prefix + ".segment." + segmentName;
     };

package/esm/storages/KeyBuilderCS.js

@@ -32,6 +32,9 @@ 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 };
@@ -47,6 +50,9 @@ export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
         },
         extractOldSegmentKey: function () {
             return undefined;
+        },
+        buildTillKey: function () {
+            return prefix + "." + matchingKey + ".largeSegments.till";
         }
     };
 }

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) {
@@ -48,11 +49,22 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     /**
      * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
      *
-     * @param {string[]} segmentNames list of segment names
+     * @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)
      */
-    MySegmentsCacheInLocal.prototype.resetSegments = function (names) {
+    MySegmentsCacheInLocal.prototype.resetSegments = function (names, changeNumber) {
         var _this = this;
+        try {
+            if (changeNumber) {
+                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+            }
+            else {
+                localStorage.removeItem(this.keys.buildTillKey());
+            }
+        }
+        catch (e) {
+            this.log.error(e);
+        }
         var isDiff = false;
         var index;
         // Scan current values from localStorage
@@ -116,6 +128,15 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
     };
+    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

@@ -32,8 +32,9 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
      * @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) {
+    MySegmentsCacheInMemory.prototype.resetSegments = function (names, changeNumber) {
         var _this = this;
+        this.cn = changeNumber;
         var isDiff = false;
         var index;
         var storedSegmentKeys = Object.keys(this.segmentCache);
@@ -63,6 +64,9 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         }
         return isDiff;
     };
+    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,4 +1,5 @@
 import { timeout } from '../../../utils/promise/timeout';
+import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 /**
  * factory of MySegments updater, a task that:
@@ -6,7 +7,8 @@ import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
  *  - 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  */
@@ -17,29 +19,31 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache
     }
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
+        var _a, _b, _c, _d;
         var shouldNotifyUpdate;
         if (Array.isArray(segmentsData)) {
-            // Update the list of segment names available
-            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+            // Add/Delete the segment names
+            segmentsData.forEach(function (_a) {
+                var isLS = _a.isLS, name = _a.name, add = _a.add;
+                var cache = isLS ? largeSegments : segments;
+                if (cache.isInSegment(name) !== add) {
+                    shouldNotifyUpdate = true;
+                    if (add)
+                        cache.addToSegment(name);
+                    else
+                        cache.removeFromSegment(name);
+                }
+            });
         }
         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;
-            }
+            // Reset the list of segment names
+            shouldNotifyUpdate = segments.resetSegments((((_a = segmentsData.ms) === null || _a === void 0 ? void 0 : _a.k) || []).map(function (segment) { return segment.n; }), (_b = segmentsData.ms) === null || _b === void 0 ? void 0 : _b.cn);
+            shouldNotifyUpdate = largeSegments.resetSegments((((_c = segmentsData.ls) === null || _c === void 0 ? void 0 : _c.k) || []).map(function (segment) { return segment.n; }), (_d = segmentsData.ls) === null || _d === void 0 ? void 0 : _d.cn) || 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/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, MY_SEGMENTS_UPDATE_V3, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_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,19 @@ 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.
-            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
+            // we only handle update events if streaming is up
+            // @ts-expect-error
+            var type = parsedData.type || parsedData.t;
+            if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(type) === -1)
                 return;
-            switch (parsedData.type) {
+            switch (type) {
                 /* update events */
                 case SPLIT_UPDATE:
                 case SEGMENT_UPDATE:
-                case MY_SEGMENTS_UPDATE_V2:
+                case MY_SEGMENTS_UPDATE_V3:
                 case MY_LARGE_SEGMENTS_UPDATE:
                 case SPLIT_KILL:
-                    pushEmitter.emit(parsedData.type, parsedData);
-                    break;
-                case MY_SEGMENTS_UPDATE:
-                    pushEmitter.emit(parsedData.type, parsedData, channel);
+                    pushEmitter.emit(type, parsedData);
                     break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case OCCUPANCY:

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

@@ -20,6 +20,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
             var syncTask = _delay ?
                 new Promise(function (res) {
                     _delayTimeoutID = setTimeout(function () {
+                        _delay = undefined;
                         mySegmentsSyncTask.execute(_segmentsData, true).then(res);
                     }, _delay);
                 }) :
@@ -46,13 +47,15 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
     }
     return {
         /**
-         * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+         * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
          *
-         * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-         * @param {SegmentsData | undefined} segmentsData might be undefined
+         * @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 (changeNumber, segmentsData, delay) {
-            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
+            // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
+            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay)
                 return;
             maxChangeNumber = changeNumber;
             handleNewEvent = true;
@@ -64,6 +67,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
         },
         stop: function () {
             clearTimeout(_delayTimeoutID);
+            _delay = undefined;
             isHandlingEvent = false;
             backoff.reset();
         }