@splitsoftware/splitio-commons 1.16.1-rc.0 → 1.16.1-rc.2

package/cjs/logger/messages/info.js

@@ -23,7 +23,7 @@ exports.codesInfo = warn_1.codesWarn.concat([
     [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
     [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
     [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
+    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
     [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/cjs/readiness/readinessManager.js

@@ -16,10 +16,9 @@ function splitsEventEmitterFactory(EventEmitter) {
     splitsEventEmitter.once(constants_1.SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
     return splitsEventEmitter;
 }
-function segmentsEventEmitterFactory(EventEmitter) {
-    var segmentsEventEmitter = (0, objectAssign_1.objectAssign)(new EventEmitter(), {
-        segmentsArrived: false
-    });
+function segmentsEventEmitterFactory(EventEmitter, segmentsArrived) {
+    if (segmentsArrived === void 0) { segmentsArrived = false; }
+    var segmentsEventEmitter = (0, objectAssign_1.objectAssign)(new EventEmitter(), { segmentsArrived: segmentsArrived });
     segmentsEventEmitter.once(constants_1.SDK_SEGMENTS_ARRIVED, function () { segmentsEventEmitter.segmentsArrived = true; });
     return segmentsEventEmitter;
 }
@@ -30,7 +29,7 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
     if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
     var _a = settings.startup, readyTimeout = _a.readyTimeout, waitForLargeSegments = _a.waitForLargeSegments, largeSegmentsEnabled = settings.sync.largeSegmentsEnabled;
     var segments = segmentsEventEmitterFactory(EventEmitter);
-    var largeSegments = largeSegmentsEnabled && waitForLargeSegments ? segmentsEventEmitterFactory(EventEmitter) : undefined;
+    var largeSegments = largeSegmentsEnabled ? segmentsEventEmitterFactory(EventEmitter, !waitForLargeSegments) : undefined;
     var gate = new EventEmitter();
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;

package/cjs/storages/pluggable/inMemoryWrapper.js

@@ -8,7 +8,7 @@ var sets_1 = require("../../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.
  */
 function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

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

@@ -15,7 +15,11 @@ function mySegmentsFetcherFactory(fetchMySegments) {
         // Extract segment names
         return mySegmentsPromise
             .then(function (resp) { return resp.json(); })
-            .then(function (json) { return json.mySegments.map(function (segment) { return segment.name; }); });
+            .then(function (json) {
+            return json.mySegments ?
+                json.mySegments.map(function (segment) { return segment.name; }) :
+                json.myLargeSegments;
+        });
     };
 }
 exports.mySegmentsFetcherFactory = mySegmentsFetcherFactory;

package/cjs/sync/polling/pollingManagerCS.js

@@ -28,12 +28,12 @@ function pollingManagerCSFactory(params) {
             if (splitsHaveSegments)
                 msSyncTask.start();
             else
-                msSyncTask.stop();
+                msSyncTask.stop(); // smart pausing
             if (mlsSyncTask) {
                 if (splitsHaveLargeSegments)
                     mlsSyncTask.start();
                 else
-                    mlsSyncTask.stop();
+                    mlsSyncTask.stop(); // smart pausing
             }
         });
     }
@@ -44,37 +44,31 @@ function pollingManagerCSFactory(params) {
             mlsSyncTask && mlsSyncTask.stop();
         });
     }
-    // smart pausing
     readiness.splits.on(constants_1.SDK_SPLITS_ARRIVED, function () {
-        // smart pausing of mySegments polling
         if (splitsSyncTask.isRunning())
             startMySegmentsSyncTasks();
     });
     function add(matchingKey, readiness, storage) {
-        var msSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMySegments, storage.segments, function () {
-            if (storage.splits.usesMatcher(constants_3.IN_SEGMENT))
-                readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
-        }, settings, matchingKey, settings.scheduler.segmentsRefreshRate);
+        var msSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMySegments, storage.segments, function () { if (storage.splits.usesMatcher(constants_3.IN_SEGMENT))
+            readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED); }, settings, matchingKey, settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
         var mlsSyncTask;
         if (settings.sync.largeSegmentsEnabled) {
-            mlsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMyLargeSegments, storage.largeSegments, function () {
-                if (readiness.largeSegments && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
-                    readiness.largeSegments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
-            }, settings, matchingKey, settings.scheduler.largeSegmentsRefreshRate);
+            mlsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMyLargeSegments, storage.largeSegments, function () { if (readiness.largeSegments && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
+                readiness.largeSegments.emit(constants_1.SDK_SEGMENTS_ARRIVED); }, settings, matchingKey, settings.scheduler.largeSegmentsRefreshRate, 'myLargeSegmentsUpdater');
         }
         // smart ready
         function smartReady() {
             if (!readiness.isReady()) {
-                if (!storage.splits.usesMatcher(constants_3.IN_SEGMENT))
-                    readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
                 if (readiness.largeSegments && !storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
                     readiness.largeSegments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
+                if (!storage.splits.usesMatcher(constants_3.IN_SEGMENT))
+                    readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
             }
         }
-        if (!storage.splits.usesMatcher(constants_3.IN_SEGMENT) && !storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
-            setTimeout(smartReady, 0);
-        else
+        if (storage.splits.usesMatcher(constants_3.IN_SEGMENT) && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
             readiness.splits.once(constants_1.SDK_SPLITS_ARRIVED, smartReady);
+        else
+            setTimeout(smartReady, 0);
         mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
         return {
             msSyncTask: msSyncTask,

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

@@ -7,7 +7,7 @@ var mySegmentsUpdater_1 = require("../updaters/mySegmentsUpdater");
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-function mySegmentsSyncTaskFactory(fetchMySegments, mySegmentsCache, notifyUpdate, settings, matchingKey, segmentsRefreshRate) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, 'mySegmentsUpdater');
+function mySegmentsSyncTaskFactory(fetchMySegments, mySegmentsCache, notifyUpdate, settings, matchingKey, segmentsRefreshRate, NAME) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, NAME);
 }
 exports.mySegmentsSyncTaskFactory = mySegmentsSyncTaskFactory;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mySegmentsUpdaterFactory = void 0;
 var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../logger/constants");
+var lang_1 = require("../../../utils/lang");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -21,23 +22,22 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notif
     // @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 ((0, lang_1.isObject)(segmentsData[0])) {
+            // Add/Delete the segment names
+            segmentsData.forEach(function (_a) {
+                var name = _a.name, add = _a.add;
+                if (mySegmentsCache.isInSegment(name) !== add) {
+                    shouldNotifyUpdate = true;
+                    if (add)
+                        mySegmentsCache.addToSegment(name);
+                    else
+                        mySegmentsCache.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 = mySegmentsCache.resetSegments(segmentsData);
         }
         // Notify update if required
         if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
@@ -78,14 +78,8 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notif
      *  (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
      */
-    return function mySegmentsUpdater(segmentsData, noCache, delay) {
-        return delay ?
-            new Promise(function (res) {
-                setTimeout(function () {
-                    _mySegmentsUpdater(0, segmentsData, noCache).then(res);
-                }, delay);
-            }) :
-            _mySegmentsUpdater(0, segmentsData, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache) {
+        return _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }
 exports.mySegmentsUpdaterFactory = mySegmentsUpdaterFactory;

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

@@ -12,6 +12,7 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
     var isHandlingEvent;
     var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
     var _delay;
+    var _delayTimeoutID;
     var backoff = new Backoff_1.Backoff(__handleMySegmentsUpdateCall);
     function __handleMySegmentsUpdateCall() {
         isHandlingEvent = true;
@@ -19,7 +20,14 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
             handleNewEvent = false;
             var currentMaxChangeNumber_1 = maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            mySegmentsSyncTask.execute(_segmentsData, true, _delay).then(function (result) {
+            var syncTask = _delay ?
+                new Promise(function (res) {
+                    _delayTimeoutID = setTimeout(function () {
+                        mySegmentsSyncTask.execute(_segmentsData, true).then(res);
+                    }, _delay);
+                }) :
+                mySegmentsSyncTask.execute(_segmentsData, true);
+            syncTask.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.
@@ -58,6 +66,7 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
             backoff.reset();
         },
         stop: function () {
+            clearTimeout(_delayTimeoutID);
             isHandlingEvent = false;
             backoff.reset();
         }

package/cjs/sync/streaming/parseUtils.js

@@ -80,15 +80,10 @@ function isInBitmap(bitmap, hash64hex) {
 exports.isInBitmap = isInBitmap;
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
 function parseFFUpdatePayload(compression, data) {
-    var avoidPrecisionLoss = false;
-    if (compression > 0)
-        return parseKeyList(data, compression, avoidPrecisionLoss);
-    else
-        return JSON.parse((0, base64_1.decodeFromBase64)(data));
+    return compression > 0 ?
+        parseKeyList(data, compression, false) :
+        JSON.parse((0, base64_1.decodeFromBase64)(data));
 }
 exports.parseFFUpdatePayload = parseFFUpdatePayload;

package/cjs/sync/streaming/pushManager.js

@@ -21,7 +21,6 @@ var murmur3_64_1 = require("../../utils/murmur3/murmur3_64");
 var constants_3 = require("../../utils/constants");
 function getDelay(parsedData, matchingKey) {
     var interval = parsedData.i || 60000;
-    // const hashType = parsedData.h || 0;
     var seed = parsedData.s || 0;
     return (0, murmur3_1.hash)(matchingKey, seed) % interval;
 }
@@ -245,14 +244,14 @@ function pushManagerFactory(params, pollingManager) {
                     var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
                     if (add !== undefined) {
                         isLS ?
-                            workerLarge && workerLarge.put(parsedData.changeNumber, {
-                                name: parsedData.largeSegments[0],
-                                add: add
-                            }) :
-                            worker.put(parsedData.changeNumber, {
-                                name: parsedData.segmentName,
-                                add: add
-                            });
+                            workerLarge && workerLarge.put(parsedData.changeNumber, [{
+                                    name: parsedData.largeSegments[0],
+                                    add: add
+                                }]) :
+                            worker.put(parsedData.changeNumber, [{
+                                    name: parsedData.segmentName,
+                                    add: add
+                                }]);
                     }
                 });
                 return;
@@ -265,16 +264,14 @@ function pushManagerFactory(params, pollingManager) {
                 (0, lang_1.forOwn)(clients, function (_a) {
                     var worker = _a.worker, workerLarge = _a.workerLarge;
                     isLS ?
-                        workerLarge && parsedData.largeSegments.forEach(function (largeSegment) {
-                            workerLarge.put(parsedData.changeNumber, {
-                                name: largeSegment,
-                                add: false
-                            });
-                        }) :
-                        worker.put(parsedData.changeNumber, {
-                            name: parsedData.segmentName,
+                        workerLarge && workerLarge.put(parsedData.changeNumber, parsedData.largeSegments.map(function (largeSegment) { return ({
+                            name: largeSegment,
                             add: false
-                        });
+                        }); })) :
+                        worker.put(parsedData.changeNumber, [{
+                                name: parsedData.segmentName,
+                                add: false
+                            }]);
                 });
                 return;
         }

package/esm/logger/messages/info.js

@@ -19,7 +19,7 @@ export var codesInfo = codesWarn.concat([
     [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
     [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
     [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
+    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
     [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/esm/readiness/readinessManager.js

@@ -13,10 +13,9 @@ function splitsEventEmitterFactory(EventEmitter) {
     splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
     return splitsEventEmitter;
 }
-function segmentsEventEmitterFactory(EventEmitter) {
-    var segmentsEventEmitter = objectAssign(new EventEmitter(), {
-        segmentsArrived: false
-    });
+function segmentsEventEmitterFactory(EventEmitter, segmentsArrived) {
+    if (segmentsArrived === void 0) { segmentsArrived = false; }
+    var segmentsEventEmitter = objectAssign(new EventEmitter(), { segmentsArrived: segmentsArrived });
     segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, function () { segmentsEventEmitter.segmentsArrived = true; });
     return segmentsEventEmitter;
 }
@@ -27,7 +26,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
     var _a = settings.startup, readyTimeout = _a.readyTimeout, waitForLargeSegments = _a.waitForLargeSegments, largeSegmentsEnabled = settings.sync.largeSegmentsEnabled;
     var segments = segmentsEventEmitterFactory(EventEmitter);
-    var largeSegments = largeSegmentsEnabled && waitForLargeSegments ? segmentsEventEmitterFactory(EventEmitter) : undefined;
+    var largeSegments = largeSegmentsEnabled ? segmentsEventEmitterFactory(EventEmitter, !waitForLargeSegments) : undefined;
     var gate = new EventEmitter();
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;

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

@@ -12,6 +12,10 @@ export function mySegmentsFetcherFactory(fetchMySegments) {
         // Extract segment names
         return mySegmentsPromise
             .then(function (resp) { return resp.json(); })
-            .then(function (json) { return json.mySegments.map(function (segment) { return segment.name; }); });
+            .then(function (json) {
+            return json.mySegments ?
+                json.mySegments.map(function (segment) { return segment.name; }) :
+                json.myLargeSegments;
+        });
     };
 }

package/esm/sync/polling/pollingManagerCS.js

@@ -25,12 +25,12 @@ export function pollingManagerCSFactory(params) {
             if (splitsHaveSegments)
                 msSyncTask.start();
             else
-                msSyncTask.stop();
+                msSyncTask.stop(); // smart pausing
             if (mlsSyncTask) {
                 if (splitsHaveLargeSegments)
                     mlsSyncTask.start();
                 else
-                    mlsSyncTask.stop();
+                    mlsSyncTask.stop(); // smart pausing
             }
         });
     }
@@ -41,37 +41,31 @@ export function pollingManagerCSFactory(params) {
             mlsSyncTask && mlsSyncTask.stop();
         });
     }
-    // smart pausing
     readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
-        // smart pausing of mySegments polling
         if (splitsSyncTask.isRunning())
             startMySegmentsSyncTasks();
     });
     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);
+        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);
+            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');
         }
         // smart ready
         function smartReady() {
             if (!readiness.isReady()) {
-                if (!storage.splits.usesMatcher(IN_SEGMENT))
-                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
                 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 (!storage.splits.usesMatcher(IN_SEGMENT) && !storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-            setTimeout(smartReady, 0);
-        else
+        if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
             readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+        else
+            setTimeout(smartReady, 0);
         mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
         return {
             msSyncTask: msSyncTask,

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) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, 'mySegmentsUpdater');
+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);
 }

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

@@ -1,5 +1,6 @@
 import { timeout } from '../../../utils/promise/timeout';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
+import { isObject } from '../../../utils/lang';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -18,23 +19,22 @@ 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 (isObject(segmentsData[0])) {
+            // Add/Delete the segment names
+            segmentsData.forEach(function (_a) {
+                var name = _a.name, add = _a.add;
+                if (mySegmentsCache.isInSegment(name) !== add) {
+                    shouldNotifyUpdate = true;
+                    if (add)
+                        mySegmentsCache.addToSegment(name);
+                    else
+                        mySegmentsCache.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 = mySegmentsCache.resetSegments(segmentsData);
         }
         // Notify update if required
         if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
@@ -75,13 +75,7 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache
      *  (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
      */
-    return function mySegmentsUpdater(segmentsData, noCache, delay) {
-        return delay ?
-            new Promise(function (res) {
-                setTimeout(function () {
-                    _mySegmentsUpdater(0, segmentsData, noCache).then(res);
-                }, delay);
-            }) :
-            _mySegmentsUpdater(0, segmentsData, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache) {
+        return _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }

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

@@ -9,6 +9,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
     var isHandlingEvent;
     var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
     var _delay;
+    var _delayTimeoutID;
     var backoff = new Backoff(__handleMySegmentsUpdateCall);
     function __handleMySegmentsUpdateCall() {
         isHandlingEvent = true;
@@ -16,7 +17,14 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
             handleNewEvent = false;
             var currentMaxChangeNumber_1 = maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            mySegmentsSyncTask.execute(_segmentsData, true, _delay).then(function (result) {
+            var syncTask = _delay ?
+                new Promise(function (res) {
+                    _delayTimeoutID = setTimeout(function () {
+                        mySegmentsSyncTask.execute(_segmentsData, true).then(res);
+                    }, _delay);
+                }) :
+                mySegmentsSyncTask.execute(_segmentsData, true);
+            syncTask.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.
@@ -55,6 +63,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, upd
             backoff.reset();
         },
         stop: function () {
+            clearTimeout(_delayTimeoutID);
             isHandlingEvent = false;
             backoff.reset();
         }

package/esm/sync/streaming/parseUtils.js

@@ -74,14 +74,9 @@ 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));
 }

package/esm/sync/streaming/pushManager.js

@@ -18,7 +18,6 @@ import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
 export function getDelay(parsedData, matchingKey) {
     var interval = parsedData.i || 60000;
-    // const hashType = parsedData.h || 0;
     var seed = parsedData.s || 0;
     return hash(matchingKey, seed) % interval;
 }
@@ -241,14 +240,14 @@ export function pushManagerFactory(params, pollingManager) {
                     var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
                     if (add !== undefined) {
                         isLS ?
-                            workerLarge && workerLarge.put(parsedData.changeNumber, {
-                                name: parsedData.largeSegments[0],
-                                add: add
-                            }) :
-                            worker.put(parsedData.changeNumber, {
-                                name: parsedData.segmentName,
-                                add: add
-                            });
+                            workerLarge && workerLarge.put(parsedData.changeNumber, [{
+                                    name: parsedData.largeSegments[0],
+                                    add: add
+                                }]) :
+                            worker.put(parsedData.changeNumber, [{
+                                    name: parsedData.segmentName,
+                                    add: add
+                                }]);
                     }
                 });
                 return;
@@ -261,16 +260,14 @@ export function pushManagerFactory(params, pollingManager) {
                 forOwn(clients, function (_a) {
                     var worker = _a.worker, workerLarge = _a.workerLarge;
                     isLS ?
-                        workerLarge && parsedData.largeSegments.forEach(function (largeSegment) {
-                            workerLarge.put(parsedData.changeNumber, {
-                                name: largeSegment,
-                                add: false
-                            });
-                        }) :
-                        worker.put(parsedData.changeNumber, {
-                            name: parsedData.segmentName,
+                        workerLarge && workerLarge.put(parsedData.changeNumber, parsedData.largeSegments.map(function (largeSegment) { return ({
+                            name: largeSegment,
                             add: false
-                        });
+                        }); })) :
+                        worker.put(parsedData.changeNumber, [{
+                                name: parsedData.segmentName,
+                                add: false
+                            }]);
                 });
                 return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.16.1-rc.0",
+  "version": "1.16.1-rc.2",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -224,14 +224,18 @@ export interface ISegmentChangesResponse {
   till: number
 }
 
-export interface IMySegmentsResponseItem {
-  id: string,
-  name: string
-}
-
 /** Interface of the parsed JSON response of `/mySegments/{userKey}` */
 export interface IMySegmentsResponse {
-  mySegments: IMySegmentsResponseItem[]
+  mySegments: {
+    id: string,
+    name: string
+  }[]
+}
+
+/** Interface of the parsed JSON response of `/myLargeSegments/{userKey}` */
+export interface IMyLargeSegmentsResponse {
+  myLargeSegments: string[],
+  changeNumber: number
 }
 
 /** Metadata internal type for storages */

package/src/logger/messages/info.ts

@@ -22,7 +22,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
   [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
   [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
-  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
+  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
   [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
   [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/src/readiness/readinessManager.ts

@@ -18,10 +18,8 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   return splitsEventEmitter;
 }
 
-function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISegmentsEventEmitter {
-  const segmentsEventEmitter = objectAssign(new EventEmitter(), {
-    segmentsArrived: false
-  });
+function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter, segmentsArrived = false): ISegmentsEventEmitter {
+  const segmentsEventEmitter = objectAssign(new EventEmitter(), { segmentsArrived });
 
   segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, () => { segmentsEventEmitter.segmentsArrived = true; });
 
@@ -39,7 +37,7 @@ export function readinessManagerFactory(
   const { startup: { readyTimeout, waitForLargeSegments }, sync: { largeSegmentsEnabled } } = settings;
 
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
-  const largeSegments = largeSegmentsEnabled && waitForLargeSegments ? segmentsEventEmitterFactory(EventEmitter) : undefined;
+  const largeSegments = largeSegmentsEnabled ? segmentsEventEmitterFactory(EventEmitter, !waitForLargeSegments) : undefined;
   const gate: IReadinessEventEmitter = new EventEmitter();
 
   // emit SDK_READY_FROM_CACHE

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -7,7 +7,7 @@ import { ISet, 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?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
 

package/src/storages/types.ts

@@ -204,7 +204,7 @@ export interface ISplitsCacheBase {
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
-  // only for Client-Side
+  // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === 1) or contains a FF using the given matcher
   usesMatcher(matcherType: string): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.

package/src/sync/polling/fetchers/mySegmentsFetcher.ts

@@ -1,5 +1,5 @@
 import { IFetchMySegments, IResponse } from '../../../services/types';
-import { IMySegmentsResponseItem } from '../../../dtos/types';
+import { IMySegmentsResponse, IMyLargeSegmentsResponse } from '../../../dtos/types';
 import { IMySegmentsFetcher } from './types';
 
 /**
@@ -21,7 +21,11 @@ export function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMy
     // Extract segment names
     return mySegmentsPromise
       .then(resp => resp.json())
-      .then(json => json.mySegments.map((segment: IMySegmentsResponseItem) => segment.name));
+      .then((json: IMySegmentsResponse | IMyLargeSegmentsResponse) => {
+        return (json as IMySegmentsResponse).mySegments ?
+          (json as IMySegmentsResponse).mySegments.map((segment) => segment.name) :
+          (json as IMyLargeSegmentsResponse).myLargeSegments;
+      });
   };
 
 }

package/src/sync/polling/pollingManagerCS.ts

@@ -35,11 +35,11 @@ export function pollingManagerCSFactory(
 
     forOwn(mySegmentsSyncTasks, ({ msSyncTask, mlsSyncTask }) => {
       if (splitsHaveSegments) msSyncTask.start();
-      else msSyncTask.stop();
+      else msSyncTask.stop(); // smart pausing
 
       if (mlsSyncTask) {
         if (splitsHaveLargeSegments) mlsSyncTask.start();
-        else mlsSyncTask.stop();
+        else mlsSyncTask.stop(); // smart pausing
       }
     });
   }
@@ -51,9 +51,7 @@ export function pollingManagerCSFactory(
     });
   }
 
-  // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    // smart pausing of mySegments polling
     if (splitsSyncTask.isRunning()) startMySegmentsSyncTasks();
   });
 
@@ -61,12 +59,11 @@ export function pollingManagerCSFactory(
     const msSyncTask = mySegmentsSyncTaskFactory(
       splitApi.fetchMySegments,
       storage.segments,
-      () => {
-        if (storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-      },
+      () => { if (storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED); },
       settings,
       matchingKey,
-      settings.scheduler.segmentsRefreshRate
+      settings.scheduler.segmentsRefreshRate,
+      'mySegmentsUpdater'
     );
 
     let mlsSyncTask;
@@ -74,24 +71,24 @@ export function pollingManagerCSFactory(
       mlsSyncTask = mySegmentsSyncTaskFactory(
         splitApi.fetchMyLargeSegments,
         storage.largeSegments!,
-        () => {
-          if (readiness.largeSegments && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
-        },
+        () => { if (readiness.largeSegments && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED); },
         settings,
         matchingKey,
-        settings.scheduler.largeSegmentsRefreshRate
+        settings.scheduler.largeSegmentsRefreshRate,
+        'myLargeSegmentsUpdater'
       );
     }
 
     // smart ready
     function smartReady() {
       if (!readiness.isReady()) {
-        if (!storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         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 (!storage.splits.usesMatcher(IN_SEGMENT) && !storage.splits.usesMatcher(IN_LARGE_SEGMENT)) setTimeout(smartReady, 0);
-    else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+
+    if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+    else setTimeout(smartReady, 0);
 
     mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
 

package/src/sync/polling/syncTasks/mySegmentsSyncTask.ts

@@ -15,7 +15,8 @@ export function mySegmentsSyncTaskFactory(
   notifyUpdate: () => void,
   settings: ISettings,
   matchingKey: string,
-  segmentsRefreshRate: number
+  segmentsRefreshRate: number,
+  NAME: string
 ): IMySegmentsSyncTask {
   return syncTaskFactory(
     settings.log,
@@ -29,6 +30,6 @@ export function mySegmentsSyncTaskFactory(
       matchingKey
     ),
     segmentsRefreshRate,
-    'mySegmentsUpdater',
+    NAME,
   );
 }

package/src/sync/polling/types.ts

@@ -12,9 +12,9 @@ export type MySegmentsData = string[] | {
   name: string,
   /* action: `true` for add, and `false` for delete */
   add: boolean
-}
+}[]
 
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, delay?: number], boolean> { }
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -4,6 +4,7 @@ import { timeout } from '../../../utils/promise/timeout';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
+import { isObject } from '../../../utils/lang';
 
 type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
 
@@ -36,19 +37,18 @@ export function mySegmentsUpdaterFactory(
   function updateSegments(segmentsData: MySegmentsData) {
 
     let shouldNotifyUpdate;
-    if (Array.isArray(segmentsData)) {
-      // Update the list of segment names available
-      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    if (isObject(segmentsData[0])) {
+      // Add/Delete the segment names
+      (segmentsData as { name: string, add: boolean }[]).forEach(({ name, add }) => {
+        if (mySegmentsCache.isInSegment(name) !== add) {
+          shouldNotifyUpdate = true;
+          if (add) mySegmentsCache.addToSegment(name);
+          else mySegmentsCache.removeFromSegment(name);
+        }
+      });
     } else {
-      // Add/Delete the segment
-      const { name, add } = segmentsData;
-      if (mySegmentsCache.isInSegment(name) !== add) {
-        shouldNotifyUpdate = true;
-        if (add) mySegmentsCache.addToSegment(name);
-        else mySegmentsCache.removeFromSegment(name);
-      } else {
-        shouldNotifyUpdate = false;
-      }
+      // Reset the list of segment names
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData as string[]);
     }
 
     // Notify update if required
@@ -94,14 +94,8 @@ export function mySegmentsUpdaterFactory(
    *  (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
    */
-  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, delay?: number) {
-    return delay ?
-      new Promise(res => {
-        setTimeout(() => {
-          _mySegmentsUpdater(0, segmentsData, noCache).then(res);
-        }, delay);
-      }) :
-      _mySegmentsUpdater(0, segmentsData, noCache);
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean) {
+    return _mySegmentsUpdater(0, segmentsData, noCache);
   };
 
 }

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -7,7 +7,7 @@ import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]> {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
@@ -15,6 +15,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
   let isHandlingEvent: boolean;
   let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
   let _delay: undefined | number;
+  let _delayTimeoutID: undefined | number;
   const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
   function __handleMySegmentsUpdateCall() {
@@ -24,7 +25,15 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
       const currentMaxChangeNumber = maxChangeNumber;
 
       // fetch mySegments revalidating data if cached
-      mySegmentsSyncTask.execute(_segmentsData, true, _delay).then((result) => {
+      const syncTask = _delay ?
+        new Promise(res => {
+          _delayTimeoutID = setTimeout(() => {
+            mySegmentsSyncTask.execute(_segmentsData, true).then(res);
+          }, _delay);
+        }) :
+        mySegmentsSyncTask.execute(_segmentsData, true);
+
+      syncTask.then((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(updateType);
@@ -61,6 +70,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
     },
 
     stop() {
+      clearTimeout(_delayTimeoutID);
       isHandlingEvent = false;
       backoff.reset();
     }

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -9,7 +9,7 @@ import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker {
+export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]> {
 
   // Handles retries with CDN bypass per segment name
   function SegmentUpdateWorker(segment: string) {

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -14,7 +14,7 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
   let maxChangeNumber = 0;
   let handleNewEvent = false;

package/src/sync/streaming/UpdateWorkers/types.ts

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
   stop(): void // clear scheduled tasks (backoff)
-  put(...args: any[]): void // handle new update event
+  put(...args: T): void // handle new update event
 }

package/src/sync/streaming/parseUtils.ts

@@ -1,6 +1,7 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
 import { Compression, KeyList } from './SSEHandler/types';
+import { ISplit } from '../../dtos/types';
 
 const GZIP = 1;
 const ZLIB = 2;
@@ -42,7 +43,7 @@ function decompress(data: string, compression: Compression) {
  * @returns {{a?: string[], r?: string[] }}
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss: boolean = true): KeyList {
+export function parseKeyList(data: string, compression: Compression, avoidPrecisionLoss = true): KeyList {
   const binKeyList = decompress(data, compression);
   let strKeyList = Uint8ArrayToString(binKeyList);
   // replace numbers to strings, to avoid losing precision
@@ -80,14 +81,9 @@ export function isInBitmap(bitmap: Uint8Array, hash64hex: string) {
 
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
-export function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined {
-  const avoidPrecisionLoss = false;
-  if (compression > 0)
-    return parseKeyList(data, compression, avoidPrecisionLoss);
-  else
-    return JSON.parse(decodeFromBase64(data));
+export function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined {
+  return compression > 0 ?
+    parseKeyList(data, compression, false) :
+    JSON.parse(decodeFromBase64(data));
 }

package/src/sync/streaming/pushManager.ts

@@ -21,11 +21,9 @@ import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IUpdateWorker } from './UpdateWorkers/types';
 
-export function getDelay(parsedData: IMyLargeSegmentsUpdateData, matchingKey: string) {
+export function getDelay(parsedData: Pick<IMyLargeSegmentsUpdateData, 'i' | 'h' | 's'>, matchingKey: string) {
   const interval = parsedData.i || 60000;
-  // const hashType = parsedData.h || 0;
   const seed = parsedData.s || 0;
 
   return hash(matchingKey, seed) % interval;
@@ -73,7 +71,7 @@ export function pushManagerFactory(
   const userKeyHashes: Record<string, string> = {};
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker, workerLarge?: IUpdateWorker }> = {};
+  const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker>, workerLarge?: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -285,14 +283,14 @@ export function pushManagerFactory(
           const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
           if (add !== undefined) {
             isLS ?
-              workerLarge && workerLarge.put(parsedData.changeNumber, {
+              workerLarge && workerLarge.put(parsedData.changeNumber, [{
                 name: parsedData.largeSegments[0],
                 add
-              }) :
-              worker.put(parsedData.changeNumber, {
+              }]) :
+              worker.put(parsedData.changeNumber, [{
                 name: parsedData.segmentName,
                 add
-              });
+              }]);
           }
         });
         return;
@@ -305,16 +303,14 @@ export function pushManagerFactory(
 
         forOwn(clients, ({ worker, workerLarge }) => {
           isLS ?
-            workerLarge && parsedData.largeSegments.forEach(largeSegment => {
-              workerLarge.put(parsedData.changeNumber, {
-                name: largeSegment,
-                add: false
-              });
-            }) :
-            worker.put(parsedData.changeNumber, {
+            workerLarge && workerLarge.put(parsedData.changeNumber, parsedData.largeSegments.map(largeSegment => ({
+              name: largeSegment,
+              add: false
+            }))) :
+            worker.put(parsedData.changeNumber, [{
               name: parsedData.segmentName,
               add: false
-            });
+            }]);
         });
         return;
     }

package/types/dtos/types.d.ts

@@ -177,13 +177,17 @@ export interface ISegmentChangesResponse {
     since: number;
     till: number;
 }
-export interface IMySegmentsResponseItem {
-    id: string;
-    name: string;
-}
 /** Interface of the parsed JSON response of `/mySegments/{userKey}` */
 export interface IMySegmentsResponse {
-    mySegments: IMySegmentsResponseItem[];
+    mySegments: {
+        id: string;
+        name: string;
+    }[];
+}
+/** Interface of the parsed JSON response of `/myLargeSegments/{userKey}` */
+export interface IMyLargeSegmentsResponse {
+    myLargeSegments: string[];
+    changeNumber: number;
 }
 /** Metadata internal type for storages */
 export interface IMetadata {

package/types/storages/pluggable/inMemoryWrapper.d.ts

@@ -5,7 +5,7 @@ import { ISet } 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 declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;

package/types/sync/polling/syncTasks/mySegmentsSyncTask.d.ts

@@ -5,4 +5,4 @@ import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, mySegmentsCache: ISegmentsCacheSync, notifyUpdate: () => void, settings: ISettings, matchingKey: string, segmentsRefreshRate: number): IMySegmentsSyncTask;
+export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, mySegmentsCache: ISegmentsCacheSync, notifyUpdate: () => void, settings: ISettings, matchingKey: string, segmentsRefreshRate: number, NAME: string): IMySegmentsSyncTask;

package/types/sync/polling/types.d.ts

@@ -12,8 +12,8 @@ export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, se
 export declare type MySegmentsData = string[] | {
     name: string;
     add: boolean;
-};
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, delay?: number], boolean> {
+}[];
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> {
 }
 export interface IPollingManager extends ITask {
     syncAll(): Promise<any>;

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,8 +1,8 @@
-import { IMySegmentsSyncTask } from '../../polling/types';
+import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker;
+export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]>;

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -1,8 +1,9 @@
 import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { ISegmentsSyncTask } from '../../polling/types';
+import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker;
+export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]>;

package/types/sync/streaming/UpdateWorkers/SplitsUpdateWorker.d.ts

@@ -1,13 +1,14 @@
+import { ISplit } from '../../../dtos/types';
 import { ILogger } from '../../../logger/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { ISplitKillData } from '../SSEHandler/types';
+import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & {
+export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & {
     killSplit(event: ISplitKillData): void;
 };

package/types/sync/streaming/UpdateWorkers/types.d.ts

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
     stop(): void;
-    put(...args: any[]): void;
+    put(...args: T): void;
 }

package/types/sync/streaming/parseUtils.d.ts

@@ -1,4 +1,5 @@
 import { Compression, KeyList } from './SSEHandler/types';
+import { ISplit } from '../../dtos/types';
 /**
  * Decode, decompress and parse the provided 'data' into a KeyList object
  *
@@ -28,8 +29,5 @@ export declare function parseBitmap(data: string, compression: Compression): Uin
 export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boolean;
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
-export declare function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined;
+export declare function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined;

package/types/sync/streaming/pushManager.d.ts

@@ -2,7 +2,7 @@ import { IPushManager } from './types';
 import { IPollingManager } from '../polling/types';
 import { IMyLargeSegmentsUpdateData } from './SSEHandler/types';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-export declare function getDelay(parsedData: IMyLargeSegmentsUpdateData, matchingKey: string): number;
+export declare function getDelay(parsedData: Pick<IMyLargeSegmentsUpdateData, 'i' | 'h' | 's'>, matchingKey: string): number;
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.