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

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, 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);
+function mySegmentsSyncTaskFactory(fetchMemberships, storage, readiness, settings, matchingKey) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMemberships), storage, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }
 exports.mySegmentsSyncTaskFactory = mySegmentsSyncTaskFactory;

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

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mySegmentsUpdaterFactory = void 0;
 var timeout_1 = require("../../../utils/promise/timeout");
-var constants_1 = require("../../../logger/constants");
+var constants_1 = require("../../../readiness/constants");
+var constants_2 = require("../../../logger/constants");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notifyUpdate, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+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  */
@@ -20,29 +22,31 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notif
     }
     // @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(constants_1.SDK_SEGMENTS_ARRIVED);
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache) {
@@ -59,7 +63,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notif
         return updaterPromise.catch(function (error) {
             if (startingUp && retriesOnFailureBeforeReady > retry) {
                 retry += 1;
-                log.warn(constants_1.SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
+                log.warn(constants_2.SYNC_MYSEGMENTS_FETCH_RETRY, [retry, error]);
                 return _mySegmentsUpdater(retry); // no need to forward `segmentList` and `noCache` params
             }
             else {

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

@@ -68,20 +68,19 @@ function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             }
             var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
             log.debug(constants_2.STREAMING_NEW_MESSAGE, [data]);
-            // we only handle update events if streaming is up.
-            if (!notificationKeeper.isStreamingUp() && [constants_1.OCCUPANCY, constants_1.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() && [constants_1.OCCUPANCY, constants_1.CONTROL].indexOf(type) === -1)
                 return;
-            switch (parsedData.type) {
+            switch (type) {
                 /* update events */
                 case constants_1.SPLIT_UPDATE:
                 case constants_1.SEGMENT_UPDATE:
-                case constants_1.MY_SEGMENTS_UPDATE_V2:
+                case constants_1.MY_SEGMENTS_UPDATE_V3:
                 case constants_1.MY_LARGE_SEGMENTS_UPDATE:
                 case constants_1.SPLIT_KILL:
-                    pushEmitter.emit(parsedData.type, parsedData);
-                    break;
-                case constants_1.MY_SEGMENTS_UPDATE:
-                    pushEmitter.emit(parsedData.type, parsedData, channel);
+                    pushEmitter.emit(type, parsedData);
                     break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case constants_1.OCCUPANCY:

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

@@ -23,6 +23,7 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
             var syncTask = _delay ?
                 new Promise(function (res) {
                     _delayTimeoutID = setTimeout(function () {
+                        _delay = undefined;
                         mySegmentsSyncTask.execute(_segmentsData, true).then(res);
                     }, _delay);
                 }) :
@@ -49,13 +50,15 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
     }
     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;
@@ -67,6 +70,7 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
         },
         stop: function () {
             clearTimeout(_delayTimeoutID);
+            _delay = undefined;
             isHandlingEvent = false;
             backoff.reset();
         }

package/cjs/sync/streaming/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.MY_LARGE_SEGMENTS_UPDATE = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MY_SEGMENTS_UPDATE_V2 = exports.MY_SEGMENTS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
+exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.MY_LARGE_SEGMENTS_UPDATE = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MY_SEGMENTS_UPDATE_V3 = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
 // time for refresh token
 exports.SECONDS_BEFORE_EXPIRATION = 600;
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -25,8 +25,7 @@ exports.PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
  */
 exports.PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 // Update-type push notifications, handled by NotificationProcessor
-exports.MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-exports.MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+exports.MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
 exports.SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 exports.SPLIT_KILL = 'SPLIT_KILL';
 exports.SPLIT_UPDATE = 'SPLIT_UPDATE';

package/cjs/sync/streaming/parseUtils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFFUpdatePayload = exports.isInBitmap = exports.parseBitmap = exports.parseKeyList = void 0;
+exports.getDelay = exports.parseFFUpdatePayload = exports.isInBitmap = exports.parseBitmap = exports.parseKeyList = void 0;
 var decompress_1 = require("../../utils/decompress");
 var base64_1 = require("../../utils/base64");
+var murmur3_1 = require("../../utils/murmur3/murmur3");
 var GZIP = 1;
 var ZLIB = 2;
 function Uint8ArrayToString(myUint8Arr) {
@@ -80,15 +81,19 @@ 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;
+var DEFAULT_MAX_INTERVAL = 60000;
+function getDelay(parsedData, matchingKey) {
+    if (parsedData.h === 0)
+        return 0;
+    var interval = parsedData.i || DEFAULT_MAX_INTERVAL;
+    var seed = parsedData.s || 0;
+    return (0, murmur3_1.hash)(matchingKey, seed) % interval;
+}
+exports.getDelay = getDelay;

package/cjs/sync/streaming/pushManager.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pushManagerFactory = exports.getDelay = void 0;
+exports.pushManagerFactory = void 0;
 var objectAssign_1 = require("../../utils/lang/objectAssign");
 var Backoff_1 = require("../../utils/Backoff");
 var SSEHandler_1 = require("./SSEHandler");
@@ -16,15 +16,8 @@ var constants_2 = require("../../logger/constants");
 var types_1 = require("./SSEHandler/types");
 var parseUtils_1 = require("./parseUtils");
 var sets_1 = require("../../utils/lang/sets");
-var murmur3_1 = require("../../utils/murmur3/murmur3");
 var murmur3_64_1 = require("../../utils/murmur3/murmur3_64");
 var constants_3 = require("../../utils/constants");
-function getDelay(parsedData, matchingKey) {
-    var interval = parsedData.i || 60000;
-    var seed = parsedData.s || 0;
-    return (0, murmur3_1.hash)(matchingKey, seed) % interval;
-}
-exports.getDelay = getDelay;
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
@@ -58,7 +51,7 @@ function pushManagerFactory(params, pollingManager) {
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [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.
+    // Hash64 is used to process MY_SEGMENTS_UPDATE events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
@@ -152,7 +145,7 @@ function pushManagerFactory(params, pollingManager) {
             (0, lang_1.forOwn)(clients, function (_a) {
                 var worker = _a.worker, workerLarge = _a.workerLarge;
                 worker.stop();
-                workerLarge && workerLarge.stop();
+                workerLarge.stop();
             });
         else
             segmentsUpdateWorker.stop();
@@ -207,7 +200,7 @@ function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.put(parsedData);
     });
     function handleMySegmentsUpdate(parsedData) {
-        var isLS = parsedData.type === constants_1.MY_LARGE_SEGMENTS_UPDATE;
+        var isLS = parsedData.t === constants_1.MY_LARGE_SEGMENTS_UPDATE;
         switch (parsedData.u) {
             case types_1.UpdateStrategy.BoundedFetchRequest: {
                 var bitmap_1;
@@ -215,15 +208,13 @@ function pushManagerFactory(params, pollingManager) {
                     bitmap_1 = (0, parseUtils_1.parseBitmap)(parsedData.d, parsedData.c);
                 }
                 catch (e) {
-                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['BoundedFetchRequest', e]);
                     break;
                 }
                 (0, lang_1.forOwn)(clients, function (_a, matchingKey) {
                     var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
                     if ((0, parseUtils_1.isInBitmap)(bitmap_1, hash64.hex)) {
-                        isLS ?
-                            workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
-                            worker.put(parsedData.changeNumber);
+                        (isLS ? workerLarge : worker).put(parsedData.cn, undefined, (0, parseUtils_1.getDelay)(parsedData, matchingKey));
                     }
                 });
                 return;
@@ -236,64 +227,50 @@ function pushManagerFactory(params, pollingManager) {
                     removed_1 = new sets_1._Set(keyList.r);
                 }
                 catch (e) {
-                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', e]);
+                    break;
+                }
+                if (!parsedData.n || !parsedData.n.length) {
+                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', 'No segment name was provided']);
                     break;
                 }
                 (0, lang_1.forOwn)(clients, function (_a) {
                     var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
                     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
-                            });
+                        (isLS ? workerLarge : worker).put(parsedData.cn, [{
+                                isLS: isLS,
+                                name: parsedData.n[0],
+                                add: add,
+                            }]);
                     }
                 });
                 return;
             }
             case types_1.UpdateStrategy.SegmentRemoval:
-                if ((isLS && parsedData.largeSegments.length === 0) || (!isLS && !parsedData.segmentName)) {
-                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+                if (!parsedData.n || !parsedData.n.length) {
+                    log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
                     break;
                 }
                 (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,
-                            add: false
-                        });
+                    (isLS ? workerLarge : worker).put(parsedData.cn, parsedData.n.map(function (largeSegment) { return ({
+                        isLS: isLS,
+                        name: largeSegment,
+                        add: false,
+                        cn: parsedData.cn
+                    }); }));
                 });
                 return;
         }
         // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
         (0, lang_1.forOwn)(clients, function (_a, matchingKey) {
             var worker = _a.worker, workerLarge = _a.workerLarge;
-            isLS ?
-                workerLarge && workerLarge.put(parsedData.changeNumber, undefined, getDelay(parsedData, matchingKey)) :
-                worker.put(parsedData.changeNumber);
+            (isLS ? workerLarge : worker).put(parsedData.cn, undefined, (0, parseUtils_1.getDelay)(parsedData, matchingKey));
         });
     }
     if (userKey) {
-        pushEmitter.on(constants_1.MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
-            var userKeyHash = channel.split('_')[2];
-            var userKey = userKeyHashes[userKeyHash];
-            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
-                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
-            }
-        });
-        pushEmitter.on(constants_1.MY_SEGMENTS_UPDATE_V2, handleMySegmentsUpdate);
+        pushEmitter.on(constants_1.MY_SEGMENTS_UPDATE_V3, handleMySegmentsUpdate);
         pushEmitter.on(constants_1.MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
     }
     else {
@@ -317,7 +294,7 @@ function pushManagerFactory(params, pollingManager) {
                 return;
             disconnected = false;
             if (userKey)
-                this.add(userKey, pollingManager.segmentsSyncTask, pollingManager.largeSegmentsSyncTask); // client-side
+                this.add(userKey, pollingManager.segmentsSyncTask); // client-side
             else
                 setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
         },
@@ -326,14 +303,14 @@ function pushManagerFactory(params, pollingManager) {
             return disconnected === false;
         },
         // [Only for client-side]
-        add: function (userKey, mySegmentsSyncTask, myLargeSegmentsSyncTask) {
+        add: function (userKey, mySegmentsSyncTask) {
             var hash = (0, AuthClient_1.hashUserKey)(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
                 clients[userKey] = {
                     hash64: (0, murmur3_64_1.hash64)(userKey),
                     worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(mySegmentsSyncTask, telemetryTracker, constants_3.MY_SEGMENT),
-                    workerLarge: myLargeSegmentsSyncTask ? (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(myLargeSegmentsSyncTask, telemetryTracker, constants_3.MY_LARGE_SEGMENT) : undefined
+                    workerLarge: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(mySegmentsSyncTask, telemetryTracker, constants_3.MY_LARGE_SEGMENT)
                 };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -65,12 +65,10 @@ function telemetryCacheConfigAdapter(telemetry, settings) {
             var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return (0, objectAssign_1.objectAssign)(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
-                lE: isClientSide ? settings.sync.largeSegmentsEnabled : undefined,
                 rR: {
                     sp: scheduler.featuresRefreshRate / 1000,
                     se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
                     ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
-                    mls: isClientSide && settings.sync.largeSegmentsEnabled ? scheduler.largeSegmentsRefreshRate / 1000 : undefined,
                     im: scheduler.impressionsRefreshRate / 1000,
                     ev: scheduler.eventsPushRate / 1000,
                     te: scheduler.telemetryRefreshRate / 1000,

package/cjs/sync/syncManagerOnline.js

@@ -117,53 +117,43 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
             shared: function (matchingKey, readinessManager, storage) {
                 if (!pollingManager)
                     return;
-                var _a = pollingManager.add(matchingKey, readinessManager, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+                var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
                 return {
-                    isRunning: msSyncTask.isRunning,
+                    isRunning: mySegmentsSyncTask.isRunning,
                     start: function () {
                         if (syncEnabled) {
                             if (pushManager) {
                                 if (pollingManager.isRunning()) {
                                     // if doing polling, we must start the periodic fetch of data
-                                    if (storage.splits.usesMatcher(constants_3.IN_SEGMENT))
-                                        msSyncTask.start();
-                                    if (mlsSyncTask && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
-                                        mlsSyncTask.start();
+                                    if (storage.splits.usesSegments())
+                                        mySegmentsSyncTask.start();
                                 }
                                 else {
                                     // if not polling, we must execute the sync task for the initial fetch
                                     // of segments since `syncAll` was already executed when starting the main client
-                                    msSyncTask.execute();
-                                    mlsSyncTask && mlsSyncTask.execute();
+                                    mySegmentsSyncTask.execute();
                                 }
-                                pushManager.add(matchingKey, msSyncTask, mlsSyncTask);
+                                pushManager.add(matchingKey, mySegmentsSyncTask);
                             }
                             else {
-                                if (storage.splits.usesMatcher(constants_3.IN_SEGMENT))
-                                    msSyncTask.start();
-                                if (mlsSyncTask && storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT))
-                                    mlsSyncTask.start();
+                                if (storage.splits.usesSegments())
+                                    mySegmentsSyncTask.start();
                             }
                         }
                         else {
-                            if (!readinessManager.isReady()) {
-                                msSyncTask.execute();
-                                mlsSyncTask && mlsSyncTask.execute();
-                            }
+                            if (!readinessManager.isReady())
+                                mySegmentsSyncTask.execute();
                         }
                     },
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
-                        var syncTasks = pollingManager.get(matchingKey);
-                        if (syncTasks) {
-                            var msSyncTask_1 = syncTasks.msSyncTask, mlsSyncTask_1 = syncTasks.mlsSyncTask;
+                        var mySegmentsSyncTask = pollingManager.get(matchingKey);
+                        if (mySegmentsSyncTask) {
                             // stop syncing
                             if (pushManager)
                                 pushManager.remove(matchingKey);
-                            if (msSyncTask_1.isRunning())
-                                msSyncTask_1.stop();
-                            if (mlsSyncTask_1 && mlsSyncTask_1.isRunning())
-                                mlsSyncTask_1.stop();
+                            if (mySegmentsSyncTask.isRunning())
+                                mySegmentsSyncTask.stop();
                             pollingManager.remove(matchingKey);
                         }
                     },

package/cjs/utils/constants/index.js

@@ -91,7 +91,7 @@ exports.NON_REQUESTED = 1;
 exports.DISABLED = 0;
 exports.ENABLED = 1;
 exports.PAUSED = 2;
-exports.FLAG_SPEC_VERSION = '1.1';
+exports.FLAG_SPEC_VERSION = '1.2';
 // Matcher types
 exports.IN_SEGMENT = 'IN_SEGMENT';
 exports.IN_LARGE_SEGMENT = 'IN_LARGE_SEGMENT';

package/cjs/utils/settingsValidation/index.js

@@ -30,8 +30,6 @@ exports.base = {
         featuresRefreshRate: 60,
         // fetch segments updates each 60 sec
         segmentsRefreshRate: 60,
-        // fetch large segments updates each 60 sec
-        largeSegmentsRefreshRate: 60,
         // publish telemetry stats each 3600 secs (1 hour)
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
@@ -77,8 +75,7 @@ exports.base = {
         impressionsMode: constants_1.OPTIMIZED,
         localhostMode: undefined,
         enabled: true,
-        flagSpecVersion: constants_1.FLAG_SPEC_VERSION,
-        largeSegmentsEnabled: false
+        flagSpecVersion: constants_1.FLAG_SPEC_VERSION
     },
     // Logger
     log: undefined
@@ -117,7 +114,6 @@ function settingsValidation(config, validationParams) {
     var scheduler = withDefaults.scheduler, startup = withDefaults.startup;
     scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-    scheduler.largeSegmentsRefreshRate = fromSecondsToMillis(scheduler.largeSegmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));

package/esm/logger/constants.js

@@ -35,6 +35,7 @@ export var IMPRESSION = 102;
 export var IMPRESSION_QUEUEING = 103;
 export var NEW_SHARED_CLIENT = 104;
 export var NEW_FACTORY = 105;
+export var POLLING_SMART_PAUSING = 106;
 export var POLLING_START = 107;
 export var POLLING_STOP = 108;
 export var SYNC_SPLITS_FETCH_RETRY = 109;
@@ -76,7 +77,7 @@ export var WARN_SPLITS_FILTER_IGNORED = 219;
 export var WARN_SPLITS_FILTER_INVALID = 220;
 export var WARN_SPLITS_FILTER_EMPTY = 221;
 export var WARN_SDK_KEY = 222;
-export var STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
+export var STREAMING_PARSING_MY_SEGMENTS_UPDATE = 223;
 export var STREAMING_PARSING_SPLIT_UPDATE = 224;
 export var WARN_INVALID_FLAGSET = 225;
 export var WARN_LOWERCASE_FLAGSET = 226;

package/esm/logger/messages/info.js

@@ -16,10 +16,11 @@ export var codesInfo = codesWarn.concat([
     [c.USER_CONSENT_NOT_UPDATED, 'UserConsent: call had no effect because it was the current consent status (%s).'],
     [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
     // synchronizer
+    [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
     [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/logger/messages/warn.js

@@ -30,7 +30,7 @@ export var codesWarn = codesError.concat([
     [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS + ': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("bySet", "byName" or "byPrefix") and a list of "values".'],
     [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': feature flag filter configuration must be a non-empty array of filter objects.'],
     [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
-    [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
+    [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
     [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
     [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
     [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],

package/esm/readiness/readinessManager.js

@@ -6,16 +6,17 @@ function splitsEventEmitterFactory(EventEmitter) {
         splitsCacheLoaded: false,
     });
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
-    // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+    // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
     // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
     splitsEventEmitter.on(SDK_SPLITS_ARRIVED, function (isSplitKill) { if (!isSplitKill)
         splitsEventEmitter.splitsArrived = true; });
     splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
     return splitsEventEmitter;
 }
-function segmentsEventEmitterFactory(EventEmitter, segmentsArrived) {
-    if (segmentsArrived === void 0) { segmentsArrived = false; }
-    var segmentsEventEmitter = objectAssign(new EventEmitter(), { segmentsArrived: segmentsArrived });
+function segmentsEventEmitterFactory(EventEmitter) {
+    var segmentsEventEmitter = objectAssign(new EventEmitter(), {
+        segmentsArrived: false
+    });
     segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, function () { segmentsEventEmitter.segmentsArrived = true; });
     return segmentsEventEmitter;
 }
@@ -24,9 +25,8 @@ function segmentsEventEmitterFactory(EventEmitter, segmentsArrived) {
  */
 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 readyTimeout = settings.startup.readyTimeout;
     var segments = segmentsEventEmitterFactory(EventEmitter);
-    var largeSegments = largeSegmentsEnabled ? segmentsEventEmitterFactory(EventEmitter, !waitForLargeSegments) : undefined;
     var gate = new EventEmitter();
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
@@ -50,8 +50,6 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     var isReady = false;
     splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
     segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
-    if (largeSegments)
-        largeSegments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
     var isDestroyed = false;
     function checkIsReadyFromCache() {
         isReadyFromCache = true;
@@ -77,7 +75,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
             }
         }
         else {
-            if (splits.splitsArrived && segments.segmentsArrived && (!largeSegments || largeSegments.segmentsArrived)) {
+            if (splits.splitsArrived && segments.segmentsArrived) {
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
@@ -94,7 +92,6 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     return {
         splits: splits,
         segments: segments,
-        largeSegments: largeSegments,
         gate: gate,
         shared: function () {
             refCount++;
@@ -109,8 +106,6 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
         destroy: function () {
             isDestroyed = true;
             segments.removeAllListeners();
-            if (largeSegments)
-                largeSegments.removeAllListeners();
             gate.removeAllListeners();
             clearTimeout(readyTimeoutId);
             if (refCount > 0)