@splitsoftware/splitio-commons 1.16.1-rc.8 → 1.17.0-rc.1

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -5,7 +5,6 @@ var tslib_1 = require("tslib");
 var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
 var sets_1 = require("../../utils/lang/sets");
-var constants_1 = require("../../utils/constants");
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
@@ -17,8 +16,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.segmentsCount = 0;
-        _this.largeSegmentsCount = 0;
+        _this.splitsWithSegmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -27,8 +25,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsCache = {};
         this.ttCache = {};
         this.changeNumber = -1;
-        this.segmentsCount = 0;
-        this.largeSegmentsCount = 0;
+        this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -38,11 +35,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Substract from segments count for the previous version of this Split.
-            if ((0, AbstractSplitsCacheSync_1.usesMatcher)(previousSplit, constants_1.IN_SEGMENT))
-                this.segmentsCount--;
-            if ((0, AbstractSplitsCacheSync_1.usesMatcher)(previousSplit, constants_1.IN_LARGE_SEGMENT))
-                this.largeSegmentsCount--;
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit)) { // Substract from segments count for the previous version of this Split.
+                this.splitsWithSegmentsCount--;
+            }
         }
         if (split) {
             // Store the Split.
@@ -52,10 +47,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
-            if ((0, AbstractSplitsCacheSync_1.usesMatcher)(split, constants_1.IN_SEGMENT))
-                this.segmentsCount++;
-            if ((0, AbstractSplitsCacheSync_1.usesMatcher)(split, constants_1.IN_LARGE_SEGMENT))
-                this.largeSegmentsCount++;
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
+                this.splitsWithSegmentsCount++;
             return true;
         }
         else {
@@ -73,10 +66,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
                 delete this.ttCache[ttName];
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
-            if ((0, AbstractSplitsCacheSync_1.usesMatcher)(split, constants_1.IN_SEGMENT))
-                this.segmentsCount--;
-            if ((0, AbstractSplitsCacheSync_1.usesMatcher)(split, constants_1.IN_LARGE_SEGMENT))
-                this.largeSegmentsCount--;
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
+                this.splitsWithSegmentsCount--;
             return true;
         }
         else {
@@ -99,8 +90,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
         return (0, lang_1.isFiniteNumber)(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
-    SplitsCacheInMemory.prototype.usesMatcher = function (matcherType) {
-        return this.getChangeNumber() === -1 || (matcherType === constants_1.IN_SEGMENT ? this.segmentsCount > 0 : this.largeSegmentsCount > 0);
+    SplitsCacheInMemory.prototype.usesSegments = function () {
+        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -23,10 +23,9 @@ function shouldRecordTelemetry(_a) {
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
+    function TelemetryCacheInMemory(splits, segments) {
         this.splits = splits;
         this.segments = segments;
-        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -42,7 +41,10 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0
+        };
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -62,8 +64,6 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
-            lseC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(constants_1.QUEUED),
             eD: this.getEventStats(constants_1.DROPPED),
@@ -195,11 +195,14 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0,
+        };
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
+        this.updatesFromSSE[type]++;
         this.e = false;
     };
     return TelemetryCacheInMemory;

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 immediately.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
 function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

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

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

package/cjs/sync/polling/pollingManagerCS.js

@@ -7,7 +7,6 @@ var splitsSyncTask_1 = require("./syncTasks/splitsSyncTask");
 var key_1 = require("../../utils/key");
 var constants_1 = require("../../readiness/constants");
 var constants_2 = require("../../logger/constants");
-var constants_3 = require("../../utils/constants");
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -16,74 +15,59 @@ function pollingManagerCSFactory(params) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = (0, splitsSyncTask_1.splitsSyncTaskFactory)(splitApi.fetchSplitChanges, storage, readiness, settings, true);
-    // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
+    // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = (0, key_1.getMatching)(settings.core.key);
-    var _a = add(matchingKey, readiness, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
     function startMySegmentsSyncTasks() {
-        var splitsHaveSegments = storage.splits.usesMatcher(constants_3.IN_SEGMENT);
-        var splitsHaveLargeSegments = storage.splits.usesMatcher(constants_3.IN_LARGE_SEGMENT);
-        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (_a) {
-            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-            if (splitsHaveSegments)
-                msSyncTask.start();
-            else
-                msSyncTask.stop(); // smart pausing
-            if (mlsSyncTask) {
-                if (splitsHaveLargeSegments)
-                    mlsSyncTask.start();
-                else
-                    mlsSyncTask.stop(); // smart pausing
-            }
+        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+            mySegmentsSyncTask.start();
         });
     }
     function stopMySegmentsSyncTasks() {
-        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (_a) {
-            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-            msSyncTask.stop();
-            mlsSyncTask && mlsSyncTask.stop();
+        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+            if (mySegmentsSyncTask.isRunning())
+                mySegmentsSyncTask.stop();
         });
     }
+    // smart pausing
     readiness.splits.on(constants_1.SDK_SPLITS_ARRIVED, function () {
-        if (splitsSyncTask.isRunning())
-            startMySegmentsSyncTasks();
+        if (!splitsSyncTask.isRunning())
+            return; // noop if not doing polling
+        var splitsHaveSegments = storage.splits.usesSegments();
+        if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
+            log.info(constants_2.POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
+            if (splitsHaveSegments) {
+                startMySegmentsSyncTasks();
+            }
+            else {
+                stopMySegmentsSyncTasks();
+            }
+        }
     });
     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, '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, 'myLargeSegmentsUpdater');
-        }
+        var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
-            if (!readiness.isReady()) {
-                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 (!readiness.isReady() && !storage.splits.usesSegments())
+                readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
         }
-        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
+        if (!storage.splits.usesSegments())
             setTimeout(smartReady, 0);
-        mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
-        return {
-            msSyncTask: msSyncTask,
-            mlsSyncTask: mlsSyncTask
-        };
+        else
+            readiness.splits.once(constants_1.SDK_SPLITS_ARRIVED, smartReady);
+        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+        return mySegmentsSyncTask;
     }
     return {
         splitsSyncTask: splitsSyncTask,
-        segmentsSyncTask: msSyncTask,
-        largeSegmentsSyncTask: mlsSyncTask,
+        segmentsSyncTask: mySegmentsSyncTask,
         // Start periodic fetching (polling)
         start: function () {
             log.info(constants_2.POLLING_START);
             splitsSyncTask.start();
-            startMySegmentsSyncTasks();
+            if (storage.splits.usesSegments())
+                startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)
         stop: function () {
@@ -97,10 +81,8 @@ function pollingManagerCSFactory(params) {
         // fetch splits and segments
         syncAll: function () {
             var promises = [splitsSyncTask.execute()];
-            (0, lang_1.forOwn)(mySegmentsSyncTasks, function (_a) {
-                var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-                promises.push(msSyncTask.execute());
-                mlsSyncTask && promises.push(mlsSyncTask.execute());
+            (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                promises.push(mySegmentsSyncTask.execute());
             });
             return Promise.all(promises);
         },

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

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

@@ -2,15 +2,15 @@
 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");
+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, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -22,27 +22,28 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notif
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        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);
-                }
-            });
+        if (Array.isArray(segmentsData)) {
+            // Update the list of segment names available
+            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
         }
         else {
-            // Reset the list of segment names
-            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+            // 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;
+            }
         }
         // Notify update if required
-        if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
+        if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
-            notifyUpdate();
+            segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED);
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache) {
@@ -59,7 +60,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/SSEClient/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SSEClient = void 0;
+var decorateHeaders_1 = require("../../../services/decorateHeaders");
 var lang_1 = require("../../../utils/lang");
 var objectAssign_1 = require("../../../utils/lang/objectAssign");
 var ABLY_API_VERSION = '1.1';
@@ -32,22 +33,18 @@ var SSEClient = /** @class */ (function () {
      * SSEClient constructor.
      *
      * @param settings Validated settings.
-     * @param useHeaders True to send metadata as headers or false to send as query params. If `true`, the provided EventSource must support headers.
      * @param platform object containing environment-specific dependencies
      * @throws 'EventSource API is not available.' if EventSource is not available.
      */
-    function SSEClient(settings, useHeaders, _a) {
+    function SSEClient(settings, _a) {
         var getEventSource = _a.getEventSource, getOptions = _a.getOptions;
+        this.settings = settings;
         this.eventSource = getEventSource && getEventSource(settings);
         // if eventSource is not available, throw an exception
         if (!this.eventSource)
             throw new Error('EventSource API is not available.');
-        this.streamingUrl = settings.urls.streaming + '/sse';
-        // @TODO get `useHeaders` flag from `getEventSource`, to use EventSource headers on client-side SDKs when possible.
-        this.useHeaders = useHeaders;
         this.headers = buildSSEHeaders(settings);
         this.options = getOptions && getOptions(settings);
-        this.lse = settings.sync.largeSegmentsEnabled;
     }
     SSEClient.prototype.setEventHandler = function (handler) {
         this.handler = handler;
@@ -59,21 +56,21 @@ var SSEClient = /** @class */ (function () {
      * @throws {TypeError} Will throw an error if `authToken` is undefined
      */
     SSEClient.prototype.open = function (authToken) {
-        var _this = this;
+        var _a;
         this.close(); // it closes connection if previously opened
         var channelsQueryParam = Object.keys(authToken.channels).map(function (channel) {
             var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
             return encodeURIComponent(params + channel);
-        }).filter(function (channel) {
-            return _this.lse || !(0, lang_1.endsWith)(channel, 'myLargeSegments');
         }).join(',');
-        var url = this.streamingUrl + "?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + ABLY_API_VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
+        var url = this.settings.urls.streaming + "/sse?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + ABLY_API_VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
+        // use headers in server-side or if getHeaderOverrides is defined
+        var useHeaders = !this.settings.core.key || ((_a = this.settings.sync.requestOptions) === null || _a === void 0 ? void 0 : _a.getHeaderOverrides);
         this.connection = new this.eventSource(
         // For client-side SDKs, SplitSDKClientKey and SplitSDKClientKey metadata is passed as query params,
         // because native EventSource implementations for browser doesn't support headers.
-        this.useHeaders ? url : url + ("&SplitSDKVersion=" + this.headers.SplitSDKVersion + "&SplitSDKClientKey=" + this.headers.SplitSDKClientKey), 
+        useHeaders ? url : url + ("&SplitSDKVersion=" + this.headers.SplitSDKVersion + "&SplitSDKClientKey=" + this.headers.SplitSDKClientKey), 
         // For server-side SDKs, metadata is passed via headers. EventSource must support headers, like 'eventsource' package for Node.
-        (0, objectAssign_1.objectAssign)(this.useHeaders ? { headers: this.headers } : {}, this.options));
+        (0, objectAssign_1.objectAssign)(useHeaders ? { headers: (0, decorateHeaders_1.decorateHeaders)(this.settings, this.headers) } : {}, this.options));
         if (this.handler) { // no need to check if SSEClient is used only by PushManager
             this.connection.addEventListener('open', this.handler.handleOpen);
             this.connection.addEventListener('message', this.handler.handleMessage);

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

@@ -76,7 +76,6 @@ function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
                 case constants_1.SPLIT_UPDATE:
                 case constants_1.SEGMENT_UPDATE:
                 case constants_1.MY_SEGMENTS_UPDATE_V2:
-                case constants_1.MY_LARGE_SEGMENTS_UPDATE:
                 case constants_1.SPLIT_KILL:
                     pushEmitter.emit(parsedData.type, parsedData);
                     break;

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

@@ -2,17 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsUpdateWorker = void 0;
 var Backoff_1 = require("../../../utils/Backoff");
+var constants_1 = require("../../../utils/constants");
 /**
  * MySegmentsUpdateWorker factory
  */
-function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType) {
+function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
     var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
     var currentChangeNumber = -1;
     var handleNewEvent = false;
     var isHandlingEvent;
     var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-    var _delay;
-    var _delayTimeoutID;
     var backoff = new Backoff_1.Backoff(__handleMySegmentsUpdateCall);
     function __handleMySegmentsUpdateCall() {
         isHandlingEvent = true;
@@ -20,20 +19,12 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
             handleNewEvent = false;
             var currentMaxChangeNumber_1 = maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            var syncTask = _delay ?
-                new Promise(function (res) {
-                    _delayTimeoutID = setTimeout(function () {
-                        _delay = undefined;
-                        mySegmentsSyncTask.execute(_segmentsData, true).then(res);
-                    }, _delay);
-                }) :
-                mySegmentsSyncTask.execute(_segmentsData, true);
-            syncTask.then(function (result) {
+            mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
                 if (!isHandlingEvent)
                     return; // halt if `stop` has been called
                 if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
                     if (_segmentsData)
-                        telemetryTracker.trackUpdatesFromSSE(updateType);
+                        telemetryTracker.trackUpdatesFromSSE(constants_1.MY_SEGMENT);
                     currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
                 }
                 if (handleNewEvent) {
@@ -50,27 +41,22 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType
     }
     return {
         /**
-         * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
+         * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
          *
-         * @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
+         * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
+         * @param {SegmentsData | undefined} segmentsData might be undefined
          */
-        put: function (changeNumber, segmentsData, delay) {
-            // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
-            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay)
+        put: function (changeNumber, segmentsData) {
+            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
                 return;
             maxChangeNumber = changeNumber;
             handleNewEvent = true;
             _segmentsData = segmentsData;
-            _delay = delay;
             if (backoff.timeoutID || !isHandlingEvent)
                 __handleMySegmentsUpdateCall();
             backoff.reset();
         },
         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.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;
 // time for refresh token
 exports.SECONDS_BEFORE_EXPIRATION = 600;
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -30,7 +30,6 @@ exports.MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 exports.SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 exports.SPLIT_KILL = 'SPLIT_KILL';
 exports.SPLIT_UPDATE = 'SPLIT_UPDATE';
-exports.MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 // Control-type push notifications, handled by NotificationKeeper
 exports.CONTROL = 'CONTROL';
 exports.OCCUPANCY = 'OCCUPANCY';

package/cjs/sync/streaming/parseUtils.js

@@ -80,10 +80,15 @@ 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) {
-    return compression > 0 ?
-        parseKeyList(data, compression, false) :
-        JSON.parse((0, base64_1.decodeFromBase64)(data));
+    var avoidPrecisionLoss = false;
+    if (compression > 0)
+        return parseKeyList(data, compression, avoidPrecisionLoss);
+    else
+        return JSON.parse((0, base64_1.decodeFromBase64)(data));
 }
 exports.parseFFUpdatePayload = parseFFUpdatePayload;