@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

package/cjs/sync/offline/splitsParser/splitsParserFromFile.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitsParserFromFileFactory = void 0;
 var tslib_1 = require("tslib");
 /* eslint-disable no-undef */
 // @TODO consider moving it to Node-SDK and remove js-yaml dependency from Js-commons
@@ -11,7 +12,6 @@ var lang_1 = require("../../../utils/lang");
 var parseCondition_1 = tslib_1.__importDefault(require("./parseCondition"));
 var logPrefix = 'sync:offline:splits-fetcher: ';
 var DEFAULT_FILENAME = '.split';
-var previousMock = 'NO_MOCK_LOADED';
 function configFilesPath(configFilePath) {
     if (configFilePath === DEFAULT_FILENAME || !lang_1.isString(configFilePath)) {
         var root = process.env.HOME;
@@ -28,81 +28,6 @@ function configFilesPath(configFilePath) {
         throw new Error("Split configuration not found in " + configFilePath + " - Please review your Split file location.");
     return configFilePath;
 }
-// Parse `.split` configuration file and return a map of "Split Objects"
-function readSplitConfigFile(log, filePath) {
-    var SPLIT_POSITION = 0;
-    var TREATMENT_POSITION = 1;
-    var data;
-    try {
-        data = fs_1.default.readFileSync(filePath, 'utf-8');
-    }
-    catch (e) {
-        log.error(e.message);
-        return {};
-    }
-    if (data === previousMock)
-        return false;
-    previousMock = data;
-    var splitObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
-        var tuple = line.trim();
-        if (tuple === '' || tuple.charAt(0) === '#') {
-            log.debug(logPrefix + ("Ignoring empty line or comment at #" + index));
-        }
-        else {
-            tuple = tuple.split(/\s+/);
-            if (tuple.length !== 2) {
-                log.debug(logPrefix + ("Ignoring line since it does not have exactly two columns #" + index));
-            }
-            else {
-                var splitName = tuple[SPLIT_POSITION];
-                var condition = parseCondition_1.default({ treatment: tuple[TREATMENT_POSITION] });
-                accum[splitName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
-            }
-        }
-        return accum;
-    }, {});
-    return splitObjects;
-}
-// Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
-function readYAMLConfigFile(log, filePath) {
-    var data = '';
-    var yamldoc = null;
-    try {
-        data = fs_1.default.readFileSync(filePath, 'utf8');
-        if (data === previousMock)
-            return false;
-        previousMock = data;
-        yamldoc = js_yaml_1.default.safeLoad(data);
-    }
-    catch (e) {
-        log.error(e);
-        return {};
-    }
-    // Each entry will be mapped to a condition, but we'll also keep the configurations map.
-    var mocksData = yamldoc.reduce(function (accum, splitEntry) {
-        var splitName = Object.keys(splitEntry)[0];
-        if (!splitName || !lang_1.isString(splitEntry[splitName].treatment))
-            log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
-        var mockData = splitEntry[splitName];
-        // "Template" for each split accumulated data
-        if (!accum[splitName]) {
-            accum[splitName] = {
-                configurations: {}, conditions: [], treatments: [], trafficTypeName: 'localhost'
-            };
-        }
-        // Assign the config if there is one on the mock
-        if (mockData.config)
-            accum[splitName].configurations[mockData.treatment] = mockData.config;
-        // Parse the condition from the entry.
-        var condition = parseCondition_1.default(mockData);
-        accum[splitName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition);
-        // Also keep track of the treatments, will be useful for manager functionality.
-        accum[splitName].treatments.push(mockData.treatment);
-        return accum;
-    }, {});
-    arrangeConditions(mocksData);
-    return mocksData;
-}
 // This function is not pure nor meant to be. Here we apply modifications to cover
 // for behaviour that's ensured by the BE.
 function arrangeConditions(mocksData) {
@@ -130,19 +55,97 @@ function arrangeConditions(mocksData) {
         delete data.treatments;
     });
 }
-// Load the content of a configuration file into an Object
-function splitsParserFromFile(_a) {
-    var features = _a.features, log = _a.log;
-    var filePath = configFilesPath(features);
-    var mockData;
-    // If we have a filePath, it means the extension is correct, choose the parser.
-    if (lang_1.endsWith(filePath, '.split')) {
-        log.warn(logPrefix + '.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
-        mockData = readSplitConfigFile(log, filePath);
+function splitsParserFromFileFactory() {
+    var previousMock = 'NO_MOCK_LOADED';
+    // Parse `.split` configuration file and return a map of "Split Objects"
+    function readSplitConfigFile(log, filePath) {
+        var SPLIT_POSITION = 0;
+        var TREATMENT_POSITION = 1;
+        var data;
+        try {
+            data = fs_1.default.readFileSync(filePath, 'utf-8');
+        }
+        catch (e) {
+            log.error(e.message);
+            return {};
+        }
+        if (data === previousMock)
+            return false;
+        previousMock = data;
+        var splitObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
+            var tuple = line.trim();
+            if (tuple === '' || tuple.charAt(0) === '#') {
+                log.debug(logPrefix + ("Ignoring empty line or comment at #" + index));
+            }
+            else {
+                tuple = tuple.split(/\s+/);
+                if (tuple.length !== 2) {
+                    log.debug(logPrefix + ("Ignoring line since it does not have exactly two columns #" + index));
+                }
+                else {
+                    var splitName = tuple[SPLIT_POSITION];
+                    var condition = parseCondition_1.default({ treatment: tuple[TREATMENT_POSITION] });
+                    accum[splitName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
+                }
+            }
+            return accum;
+        }, {});
+        return splitObjects;
     }
-    else {
-        mockData = readYAMLConfigFile(log, filePath);
+    // Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
+    function readYAMLConfigFile(log, filePath) {
+        var data = '';
+        var yamldoc = null;
+        try {
+            data = fs_1.default.readFileSync(filePath, 'utf8');
+            if (data === previousMock)
+                return false;
+            previousMock = data;
+            yamldoc = js_yaml_1.default.safeLoad(data);
+        }
+        catch (e) {
+            log.error(e);
+            return {};
+        }
+        // Each entry will be mapped to a condition, but we'll also keep the configurations map.
+        var mocksData = yamldoc.reduce(function (accum, splitEntry) {
+            var splitName = Object.keys(splitEntry)[0];
+            if (!splitName || !lang_1.isString(splitEntry[splitName].treatment))
+                log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
+            var mockData = splitEntry[splitName];
+            // "Template" for each split accumulated data
+            if (!accum[splitName]) {
+                accum[splitName] = {
+                    configurations: {}, conditions: [], treatments: [], trafficTypeName: 'localhost'
+                };
+            }
+            // Assign the config if there is one on the mock
+            if (mockData.config)
+                accum[splitName].configurations[mockData.treatment] = mockData.config;
+            // Parse the condition from the entry.
+            var condition = parseCondition_1.default(mockData);
+            accum[splitName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition);
+            // Also keep track of the treatments, will be useful for manager functionality.
+            accum[splitName].treatments.push(mockData.treatment);
+            return accum;
+        }, {});
+        arrangeConditions(mocksData);
+        return mocksData;
     }
-    return mockData;
+    // Load the content of a configuration file into an Object
+    return function splitsParserFromFile(_a) {
+        var features = _a.features, log = _a.log;
+        var filePath = configFilesPath(features);
+        var mockData;
+        // If we have a filePath, it means the extension is correct, choose the parser.
+        if (lang_1.endsWith(filePath, '.split')) {
+            log.warn(logPrefix + '.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
+            mockData = readSplitConfigFile(log, filePath);
+        }
+        else {
+            mockData = readYAMLConfigFile(log, filePath);
+        }
+        return mockData;
+    };
 }
-exports.default = splitsParserFromFile;
+exports.splitsParserFromFileFactory = splitsParserFromFileFactory;

package/cjs/sync/offline/splitsParser/splitsParserFromSettings.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitsParserFromSettingsFactory = void 0;
 var tslib_1 = require("tslib");
 var lang_1 = require("../../../utils/lang");
 var parseCondition_1 = tslib_1.__importDefault(require("./parseCondition"));
-var previousMock = { 'emptyMock': '1' };
 function hasTreatmentChanged(prev, curr) {
     if (typeof prev !== typeof curr)
         return true;
@@ -14,47 +14,50 @@ function hasTreatmentChanged(prev, curr) {
         return prev.treatment !== curr.treatment || prev.config !== curr.config;
     }
 }
-function mockUpdated(currentData) {
-    var names = Object.keys(currentData);
-    // Different amount of items
-    if (names.length !== Object.keys(previousMock).length) {
-        previousMock = currentData;
-        return true;
-    }
-    return names.some(function (name) {
-        var newSplit = !previousMock[name];
-        var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
-        var changed = newSplit || newTreatment;
-        if (changed)
+function splitsParserFromSettingsFactory() {
+    var previousMock = { 'emptyMock': '1' };
+    function mockUpdated(currentData) {
+        var names = Object.keys(currentData);
+        // Different amount of items
+        if (names.length !== Object.keys(previousMock).length) {
             previousMock = currentData;
-        return changed;
-    });
-}
-/**
- *
- * @param features validated object with mocked features mapping.
- */
-function splitsParserFromSettings(settings) {
-    var features = settings.features || {};
-    if (!mockUpdated(features))
-        return false;
-    var splitObjects = {};
-    lang_1.forOwn(features, function (data, splitName) {
-        var treatment = data;
-        var config = null;
-        if (lang_1.isObject(data)) {
-            treatment = data.treatment;
-            config = data.config || config;
+            return true;
         }
-        var configurations = {};
-        if (config !== null)
-            configurations[treatment] = config;
-        splitObjects[splitName] = {
-            trafficTypeName: 'localhost',
-            conditions: [parseCondition_1.default({ treatment: treatment })],
-            configurations: configurations
-        };
-    });
-    return splitObjects;
+        return names.some(function (name) {
+            var newSplit = !previousMock[name];
+            var newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
+            var changed = newSplit || newTreatment;
+            if (changed)
+                previousMock = currentData;
+            return changed;
+        });
+    }
+    /**
+     *
+     * @param settings validated object with mocked features mapping.
+     */
+    return function splitsParserFromSettings(settings) {
+        var features = settings.features || {};
+        if (!mockUpdated(features))
+            return false;
+        var splitObjects = {};
+        lang_1.forOwn(features, function (data, splitName) {
+            var treatment = data;
+            var config = null;
+            if (lang_1.isObject(data)) {
+                treatment = data.treatment;
+                config = data.config || config;
+            }
+            var configurations = {};
+            if (config !== null)
+                configurations[treatment] = config;
+            splitObjects[splitName] = {
+                trafficTypeName: 'localhost',
+                conditions: [parseCondition_1.default({ treatment: treatment })],
+                configurations: configurations
+            };
+        });
+        return splitObjects;
+    };
 }
-exports.default = splitsParserFromSettings;
+exports.splitsParserFromSettingsFactory = splitsParserFromSettingsFactory;

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -11,7 +11,8 @@ var constants_3 = require("../../../logger/constants");
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
-    var log = settings.log;
+    var log = settings.log, splitsCache = storage.splits;
+    var startingUp = true;
     return function objectUpdater() {
         var splits = [];
         var loadError = null;
@@ -41,11 +42,20 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 ]);
             });
             return Promise.all([
-                storage.splits.clear(),
-                storage.splits.addSplits(splits)
+                splitsCache.clear(),
+                splitsCache.addSplits(splits)
             ]).then(function () {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
-                readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+                if (startingUp) {
+                    startingUp = false;
+                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
+                        // Emits SDK_READY_FROM_CACHE
+                        if (cacheReady)
+                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+                        // Emits SDK_READY
+                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+                    });
+                }
                 return true;
             });
         }

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

@@ -24,19 +24,36 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
         // mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise);
     }
     // @TODO if allowing custom storages, handle async execution
-    function updateSegments(segments) {
-        // Update the list of segment names available
-        var shouldNotifyUpdate = mySegmentsCache.resetSegments(segments);
+    function updateSegments(segmentsData) {
+        var shouldNotifyUpdate;
+        if (Array.isArray(segmentsData)) {
+            // Update the list of segment names available
+            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+        }
+        else {
+            // Add/Delete the segment
+            var name_1 = segmentsData.name, add = segmentsData.add;
+            if (mySegmentsCache.isInSegment(name_1) !== add) {
+                shouldNotifyUpdate = true;
+                if (add)
+                    mySegmentsCache.addToSegment(name_1);
+                else
+                    mySegmentsCache.removeFromSegment(name_1);
+            }
+            else {
+                shouldNotifyUpdate = false;
+            }
+        }
         // Notify update if required
         if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED);
         }
     }
-    function _mySegmentsUpdater(retry, segmentList, noCache) {
-        var updaterPromise = segmentList ?
-            // If segmentList is provided, there is no need to fetch mySegments
-            new Promise(function (res) { updateSegments(segmentList); res(true); }) :
+    function _mySegmentsUpdater(retry, segmentsData, noCache) {
+        var updaterPromise = segmentsData ?
+            // If segmentsData is provided, there is no need to fetch mySegments
+            new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
             mySegmentsFetcher(noCache, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
@@ -60,11 +77,14 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
      * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
      * Returned promise will not be rejected.
      *
-     * @param {string[] | undefined} segmentList list of mySegments names to sync in the storage. If the list is `undefined`, it fetches them before syncing in the storage.
+     * @param {SegmentsData | undefined} segmentsData it can be:
+     *  (1) the list of mySegments names to sync in the storage,
+     *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
+     *  (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(segmentList, noCache) {
-        return _mySegmentsUpdater(0, segmentList, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache) {
+        return _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }
 exports.mySegmentsUpdaterFactory = mySegmentsUpdaterFactory;

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

@@ -40,7 +40,6 @@ var SSEClient = /** @class */ (function () {
         if (!this.eventSource)
             throw new Error('EventSource API is not available. ');
         this.streamingUrl = settings.urls.streaming + '/sse';
-        this.reopen = this.reopen.bind(this);
         // @TODO get `useHeaders` flag from `getEventSource`, to use EventSource headers on client-side SDKs when possible.
         this.useHeaders = useHeaders;
         this.headers = buildSSEHeaders(settings);
@@ -56,7 +55,6 @@ var SSEClient = /** @class */ (function () {
      */
     SSEClient.prototype.open = function (authToken) {
         this.close(); // it closes connection if previously opened
-        this.authToken = authToken;
         var channelsQueryParam = Object.keys(authToken.channels).map(function (channel) {
             var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
             return encodeURIComponent(params + channel);
@@ -79,15 +77,6 @@ var SSEClient = /** @class */ (function () {
         if (this.connection)
             this.connection.close();
     };
-    /**
-     * Re-open the connection with the last given authToken.
-     *
-     * @throws {TypeError} if `open` has not been previously called with an authToken
-     * @TODO this method is not used currently and could be removed.
-     */
-    SSEClient.prototype.reopen = function () {
-        this.open(this.authToken);
-    };
     return SSEClient;
 }());
 exports.default = SSEClient;

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

@@ -54,6 +54,13 @@ function notificationKeeperFactory(pushEmitter) {
             }
         },
         handleControlEvent: function (controlType, channel, timestamp) {
+            /* STREAMING_RESET control event is handled by PushManager directly since it doesn't require
+             * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous
+             * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */
+            if (controlType === constants_1.ControlType.STREAMING_RESET) {
+                pushEmitter.emit(controlType);
+                return;
+            }
             for (var i = 0; i < channels.length; i++) {
                 var c = channels[i];
                 if (c.regex.test(channel)) {

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

@@ -23,10 +23,13 @@ exports.errorParser = errorParser;
  * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
  *
  * @param message
- * @returns parsed notification message
+ * @returns parsed notification message or undefined if the given event data is falsy (e.g, '' or undefined).
+ * For example, the EventSource implementation of React-Native for iOS emits a message event with empty data for Ably keepalive comments.
  * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
  */
 function messageParser(message) {
+    if (!message.data)
+        return;
     var messageData = JSON.parse(message.data);
     messageData.parsedData = JSON.parse(messageData.data);
     // set the event type to OCCUPANCY, to handle all events uniformely

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

@@ -39,7 +39,7 @@ function SSEHandlerFactory(log, pushEmitter) {
             catch (err) {
                 log.warn(constants_2.STREAMING_PARSING_ERROR_FAILS, [err]);
             }
-            var errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message;
+            var errorMessage = (errorWithParsedData.parsedData && errorWithParsedData.parsedData.message) || errorWithParsedData.message;
             log.error(constants_2.ERROR_STREAMING_SSE, [errorMessage]);
             if (isRetryableError(errorWithParsedData)) {
                 pushEmitter.emit(constants_1.PUSH_RETRYABLE_ERROR);
@@ -53,6 +53,8 @@ function SSEHandlerFactory(log, pushEmitter) {
             var messageWithParsedData;
             try {
                 messageWithParsedData = NotificationParser_1.messageParser(message);
+                if (!messageWithParsedData)
+                    return; // Messages with empty data are ignored
             }
             catch (err) {
                 log.warn(constants_2.STREAMING_PARSING_MESSAGE_FAILS, [err]);
@@ -61,21 +63,18 @@ function SSEHandlerFactory(log, pushEmitter) {
             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() && parsedData.type !== constants_1.OCCUPANCY && parsedData.type !== constants_1.CONTROL)
+            if (!notificationKeeper.isStreamingUp() && [constants_1.OCCUPANCY, constants_1.CONTROL].indexOf(parsedData.type) === -1)
                 return;
             switch (parsedData.type) {
                 /* update events */
                 case constants_1.SPLIT_UPDATE:
-                    pushEmitter.emit(constants_1.SPLIT_UPDATE, parsedData.changeNumber);
-                    break;
                 case constants_1.SEGMENT_UPDATE:
-                    pushEmitter.emit(constants_1.SEGMENT_UPDATE, parsedData.changeNumber, parsedData.segmentName);
+                case constants_1.MY_SEGMENTS_UPDATE_V2:
+                case constants_1.SPLIT_KILL:
+                    pushEmitter.emit(parsedData.type, parsedData);
                     break;
                 case constants_1.MY_SEGMENTS_UPDATE:
-                    pushEmitter.emit(constants_1.MY_SEGMENTS_UPDATE, parsedData, channel);
-                    break;
-                case constants_1.SPLIT_KILL:
-                    pushEmitter.emit(constants_1.SPLIT_KILL, parsedData.changeNumber, parsedData.splitName, parsedData.defaultTreatment);
+                    pushEmitter.emit(parsedData.type, parsedData, channel);
                     break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case constants_1.OCCUPANCY:

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

@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateStrategy = exports.Compression = void 0;
+var Compression;
+(function (Compression) {
+    Compression[Compression["None"] = 0] = "None";
+    Compression[Compression["Gzip"] = 1] = "Gzip";
+    Compression[Compression["Zlib"] = 2] = "Zlib";
+})(Compression = exports.Compression || (exports.Compression = {}));
+var UpdateStrategy;
+(function (UpdateStrategy) {
+    UpdateStrategy[UpdateStrategy["UnboundedFetchRequest"] = 0] = "UnboundedFetchRequest";
+    UpdateStrategy[UpdateStrategy["BoundedFetchRequest"] = 1] = "BoundedFetchRequest";
+    UpdateStrategy[UpdateStrategy["KeyList"] = 2] = "KeyList";
+    UpdateStrategy[UpdateStrategy["SegmentRemoval"] = 3] = "SegmentRemoval";
+})(UpdateStrategy = exports.UpdateStrategy || (exports.UpdateStrategy = {}));

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

@@ -13,7 +13,7 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
         this.mySegmentsSyncTask = mySegmentsSyncTask;
         this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
         this.handleNewEvent = false;
-        this.segmentList = undefined; // keeps the segmentList (if included in payload) from the queued event with maximum changeNumber
+        this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
         this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
         this.put = this.put.bind(this);
         this.__handleMySegmentsUpdateCall = this.__handleMySegmentsUpdateCall.bind(this);
@@ -27,7 +27,7 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
             this.handleNewEvent = false;
             var currentMaxChangeNumber_1 = this.maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            this.mySegmentsSyncTask.execute(this.segmentList, true).then(function (result) {
+            this.mySegmentsSyncTask.execute(this.segmentsData, true).then(function (result) {
                 if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
                     _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
                 if (_this.handleNewEvent) {
@@ -43,15 +43,15 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
      * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
      *
      * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {string[] | undefined} segmentList might be undefined
+     * @param {SegmentsData | undefined} segmentsData might be undefined
      */
-    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentList) {
+    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentsData) {
         if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber)
             return;
         this.maxChangeNumber = changeNumber;
         this.handleNewEvent = true;
         this.backoff.reset();
-        this.segmentList = segmentList;
+        this.segmentsData = segmentsData;
         if (this.mySegmentsSyncTask.isExecuting())
             return;
         this.__handleMySegmentsUpdateCall();

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

@@ -57,7 +57,8 @@ var SegmentsUpdateWorker = /** @class */ (function () {
      * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
      * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
      */
-    SegmentsUpdateWorker.prototype.put = function (changeNumber, segmentName) {
+    SegmentsUpdateWorker.prototype.put = function (_a) {
+        var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
         var currentChangeNumber = this.segmentsCache.getChangeNumber(segmentName);
         if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName])
             return;

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

@@ -49,7 +49,8 @@ var SplitsUpdateWorker = /** @class */ (function () {
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    SplitsUpdateWorker.prototype.put = function (changeNumber) {
+    SplitsUpdateWorker.prototype.put = function (_a) {
+        var changeNumber = _a.changeNumber;
         var currentChangeNumber = this.splitsCache.getChangeNumber();
         if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber)
             return;
@@ -67,14 +68,15 @@ var SplitsUpdateWorker = /** @class */ (function () {
      * @param {string} splitName name of split to kill
      * @param {string} defaultTreatment default treatment value
      */
-    SplitsUpdateWorker.prototype.killSplit = function (changeNumber, splitName, defaultTreatment) {
+    SplitsUpdateWorker.prototype.killSplit = function (_a) {
+        var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
         // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
         if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
             // trigger an SDK_UPDATE if Split was killed locally
             this.splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, true);
         }
         // queues the SplitChanges fetch (only if changeNumber is newer)
-        this.put(changeNumber);
+        this.put({ changeNumber: changeNumber });
     };
     return SplitsUpdateWorker;
 }());

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.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = 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
@@ -26,6 +26,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.SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 exports.SPLIT_KILL = 'SPLIT_KILL';
 exports.SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -37,4 +38,5 @@ var ControlType;
     ControlType["STREAMING_DISABLED"] = "STREAMING_DISABLED";
     ControlType["STREAMING_PAUSED"] = "STREAMING_PAUSED";
     ControlType["STREAMING_RESUMED"] = "STREAMING_RESUMED";
+    ControlType["STREAMING_RESET"] = "STREAMING_RESET";
 })(ControlType = exports.ControlType || (exports.ControlType = {}));