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

package/esm/services/splitHttpClient.js

@@ -1,5 +1,6 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
+import { decorateHeaders } from './decorateHeaders';
 var messageNoFetch = 'Global fetch API is not available.';
 /**
  * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.
@@ -15,22 +16,22 @@ export function splitHttpClientFactory(settings, _a) {
     // if fetch is not available, log Error
     if (!fetch)
         log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
-    var headers = {
+    var commonHeaders = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
         'Authorization': "Bearer " + authorizationKey,
         'SplitSDKVersion': version
     };
     if (ip)
-        headers['SplitSDKMachineIP'] = ip;
+        commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
-        headers['SplitSDKMachineName'] = hostname;
+        commonHeaders['SplitSDKMachineName'] = hostname;
     return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
         if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
         var request = objectAssign({
-            headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
+            headers: decorateHeaders(settings, objectAssign({}, commonHeaders, reqOpts.headers || {})),
             method: reqOpts.method || 'GET',
             body: reqOpts.body
         }, options);

package/esm/storages/AbstractSplitsCacheAsync.js

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

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,4 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+import { IN_SEGMENT } from '../utils/constants';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -59,14 +60,14 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
 export { AbstractSplitsCacheSync };
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesMatcher` method
+ * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
  */
-export function usesMatcher(split, matcherType) {
+export function usesSegments(split) {
     var conditions = split.conditions || [];
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         for (var j = 0; j < matchers.length; j++) {
-            if (matchers[j].matcherType === matcherType)
+            if (matchers[j].matcherType === IN_SEGMENT)
                 return true;
         }
     }

package/esm/storages/KeyBuilder.js

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

package/esm/storages/KeyBuilderCS.js

@@ -21,6 +21,10 @@ var KeyBuilderCS = /** @class */ (function (_super) {
             return builtSegmentKeyName.substr(prefix.length);
     };
     // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+    KeyBuilderCS.prototype.buildOldSegmentNameKey = function (segmentName) {
+        return this.matchingKey + "." + this.prefix + ".segment." + segmentName;
+    };
+    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
     KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {
         var prefix = this.matchingKey + "." + this.prefix + ".segment.";
         if (startsWith(builtSegmentKeyName, prefix))
@@ -35,18 +39,3 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     return KeyBuilderCS;
 }(KeyBuilder));
 export { KeyBuilderCS };
-export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
-    return {
-        buildSegmentNameKey: function (segmentName) {
-            return prefix + "." + matchingKey + ".largeSegment." + segmentName;
-        },
-        extractSegmentName: function (builtSegmentKeyName) {
-            var p = prefix + "." + matchingKey + ".largeSegment.";
-            if (startsWith(builtSegmentKeyName, p))
-                return builtSegmentKeyName.substr(p.length);
-        },
-        extractOldSegmentKey: function () {
-            return undefined;
-        }
-    };
-}

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -1,10 +1,9 @@
 import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { _Set, setToArray } from '../../utils/lang/sets';
 import { getStorageHash } from '../KeyBuilder';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -38,14 +37,10 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             if (split) {
                 var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
                 this._decrementCount(ttKey);
-                if (usesMatcher(split, IN_SEGMENT)) {
+                if (usesSegments(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     this._decrementCount(segmentsCountKey);
                 }
-                if (usesMatcher(split, IN_LARGE_SEGMENT)) {
-                    var segmentsCountKey = this.keys.buildSplitsWithLargeSegmentCountKey();
-                    this._decrementCount(segmentsCountKey);
-                }
             }
         }
         catch (e) {
@@ -58,16 +53,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
                 // @ts-expect-error
                 localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-                if (usesMatcher(split, IN_SEGMENT)) {
+                if (usesSegments(split)) {
                     var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                     // @ts-expect-error
                     localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
                 }
-                if (usesMatcher(split, IN_LARGE_SEGMENT)) {
-                    var segmentsCountKey = this.keys.buildSplitsWithLargeSegmentCountKey();
-                    // @ts-expect-error
-                    localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
-                }
             }
         }
         catch (e) {
@@ -180,13 +170,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         var ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
         return isFiniteNumber(ttCount) && ttCount > 0;
     };
-    SplitsCacheInLocal.prototype.usesMatcher = function (matcherType) {
+    SplitsCacheInLocal.prototype.usesSegments = function () {
         // If cache hasn't been synchronized with the cloud, assume we need them.
         if (!this.hasSync)
             return true;
-        var storedCount = localStorage.getItem(matcherType === IN_SEGMENT ?
-            this.keys.buildSplitsWithSegmentCountKey() :
-            this.keys.buildSplitsWithLargeSegmentCountKey());
+        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
         if (isFiniteNumber(splitsWithSegmentsCount)) {
             return splitsWithSegmentsCount > 0;

package/esm/storages/inLocalStorage/index.js

@@ -2,7 +2,7 @@ import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -33,11 +33,9 @@ export function InLocalStorage(options) {
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
-        var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
         return {
             splits: splits,
             segments: segments,
-            largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory(eventsQueueSize),
@@ -47,7 +45,6 @@ export function InLocalStorage(options) {
                 var _a;
                 this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                 this.segments = new MySegmentsCacheInMemory();
-                this.largeSegments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
@@ -55,10 +52,10 @@ export function InLocalStorage(options) {
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
+                var childKeysBuilder = new KeyBuilderCS(prefix, matchingKey);
                 return {
                     splits: this.splits,
-                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
-                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
+                    segments: new MySegmentsCacheInLocal(log, childKeysBuilder),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,
@@ -66,7 +63,6 @@ export function InLocalStorage(options) {
                     destroy: function () {
                         this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                         this.segments = new MySegmentsCacheInMemory();
-                        this.largeSegments = new MySegmentsCacheInMemory();
                     }
                 };
             },

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -15,11 +15,9 @@ export function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
-    var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
         segments: segments,
-        largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(eventsQueueSize),
@@ -29,7 +27,6 @@ export function InMemoryStorageCSFactory(params) {
         destroy: function () {
             this.splits.clear();
             this.segments.clear();
-            this.largeSegments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
@@ -40,7 +37,6 @@ export function InMemoryStorageCSFactory(params) {
             return {
                 splits: this.splits,
                 segments: new MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -49,7 +45,6 @@ export function InMemoryStorageCSFactory(params) {
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
-                    this.largeSegments.clear();
                 }
             };
         },

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,8 +1,7 @@
 import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
 import { _Set } from '../../utils/lang/sets';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
@@ -14,8 +13,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;
@@ -24,8 +22,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);
@@ -35,11 +32,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Substract from segments count for the previous version of this Split.
-            if (usesMatcher(previousSplit, IN_SEGMENT))
-                this.segmentsCount--;
-            if (usesMatcher(previousSplit, IN_LARGE_SEGMENT))
-                this.largeSegmentsCount--;
+            if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
+                this.splitsWithSegmentsCount--;
+            }
         }
         if (split) {
             // Store the Split.
@@ -49,10 +44,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
-            if (usesMatcher(split, IN_SEGMENT))
-                this.segmentsCount++;
-            if (usesMatcher(split, IN_LARGE_SEGMENT))
-                this.largeSegmentsCount++;
+            if (usesSegments(split))
+                this.splitsWithSegmentsCount++;
             return true;
         }
         else {
@@ -70,10 +63,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
                 delete this.ttCache[ttName];
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
-            if (usesMatcher(split, IN_SEGMENT))
-                this.segmentsCount--;
-            if (usesMatcher(split, IN_LARGE_SEGMENT))
-                this.largeSegmentsCount--;
+            if (usesSegments(split))
+                this.splitsWithSegmentsCount--;
             return true;
         }
         else {
@@ -96,8 +87,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
         return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
-    SplitsCacheInMemory.prototype.usesMatcher = function (matcherType) {
-        return this.getChangeNumber() === -1 || (matcherType === IN_SEGMENT ? this.segmentsCount > 0 : this.largeSegmentsCount > 0);
+    SplitsCacheInMemory.prototype.usesSegments = function () {
+        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -18,10 +18,9 @@ export function shouldRecordTelemetry(_a) {
     return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 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;
@@ -37,7 +36,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 () { };
@@ -57,8 +59,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(QUEUED),
             eD: this.getEventStats(DROPPED),
@@ -190,11 +190,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/esm/storages/pluggable/inMemoryWrapper.js

@@ -5,7 +5,7 @@ import { setToArray, _Set } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
 export function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

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

@@ -12,10 +12,6 @@ export 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; }); });
     };
 }

package/esm/sync/polling/pollingManagerCS.js

@@ -3,8 +3,7 @@ import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-import { POLLING_START, POLLING_STOP } from '../../logger/constants';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
+import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -13,74 +12,59 @@ export function pollingManagerCSFactory(params) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
-    // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
+    // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = getMatching(settings.core.key);
-    var _a = add(matchingKey, readiness, storage), msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
+    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
     function startMySegmentsSyncTasks() {
-        var splitsHaveSegments = storage.splits.usesMatcher(IN_SEGMENT);
-        var splitsHaveLargeSegments = storage.splits.usesMatcher(IN_LARGE_SEGMENT);
-        forOwn(mySegmentsSyncTasks, function (_a) {
-            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-            if (splitsHaveSegments)
-                msSyncTask.start();
-            else
-                msSyncTask.stop(); // smart pausing
-            if (mlsSyncTask) {
-                if (splitsHaveLargeSegments)
-                    mlsSyncTask.start();
-                else
-                    mlsSyncTask.stop(); // smart pausing
-            }
+        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+            mySegmentsSyncTask.start();
         });
     }
     function stopMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (_a) {
-            var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-            msSyncTask.stop();
-            mlsSyncTask && mlsSyncTask.stop();
+        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+            if (mySegmentsSyncTask.isRunning())
+                mySegmentsSyncTask.stop();
         });
     }
+    // smart pausing
     readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
-        if (splitsSyncTask.isRunning())
-            startMySegmentsSyncTasks();
+        if (!splitsSyncTask.isRunning())
+            return; // noop if not doing polling
+        var splitsHaveSegments = storage.splits.usesSegments();
+        if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
+            log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
+            if (splitsHaveSegments) {
+                startMySegmentsSyncTasks();
+            }
+            else {
+                stopMySegmentsSyncTasks();
+            }
+        }
     });
     function add(matchingKey, readiness, storage) {
-        var msSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage.segments, function () { if (storage.splits.usesMatcher(IN_SEGMENT))
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED); }, settings, matchingKey, settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
-        var mlsSyncTask;
-        if (settings.sync.largeSegmentsEnabled) {
-            mlsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMyLargeSegments, storage.largeSegments, function () { if (readiness.largeSegments && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-                readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED); }, settings, matchingKey, settings.scheduler.largeSegmentsRefreshRate, 'myLargeSegmentsUpdater');
-        }
+        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
-            if (!readiness.isReady()) {
-                if (readiness.largeSegments && !storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-                    readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
-                if (!storage.splits.usesMatcher(IN_SEGMENT))
-                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-            }
+            if (!readiness.isReady() && !storage.splits.usesSegments())
+                readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }
-        if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT))
-            readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
-        else
+        if (!storage.splits.usesSegments())
             setTimeout(smartReady, 0);
-        mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
-        return {
-            msSyncTask: msSyncTask,
-            mlsSyncTask: mlsSyncTask
-        };
+        else
+            readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+        return mySegmentsSyncTask;
     }
     return {
         splitsSyncTask: splitsSyncTask,
-        segmentsSyncTask: msSyncTask,
-        largeSegmentsSyncTask: mlsSyncTask,
+        segmentsSyncTask: mySegmentsSyncTask,
         // Start periodic fetching (polling)
         start: function () {
             log.info(POLLING_START);
             splitsSyncTask.start();
-            startMySegmentsSyncTasks();
+            if (storage.splits.usesSegments())
+                startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)
         stop: function () {
@@ -94,10 +78,8 @@ export function pollingManagerCSFactory(params) {
         // fetch splits and segments
         syncAll: function () {
             var promises = [splitsSyncTask.execute()];
-            forOwn(mySegmentsSyncTasks, function (_a) {
-                var msSyncTask = _a.msSyncTask, mlsSyncTask = _a.mlsSyncTask;
-                promises.push(msSyncTask.execute());
-                mlsSyncTask && promises.push(mlsSyncTask.execute());
+            forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                promises.push(mySegmentsSyncTask.execute());
             });
             return Promise.all(promises);
         },

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

@@ -4,6 +4,6 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export function mySegmentsSyncTaskFactory(fetchMySegments, mySegmentsCache, notifyUpdate, settings, matchingKey, segmentsRefreshRate, NAME) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), mySegmentsCache, notifyUpdate, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), segmentsRefreshRate, NAME);
+export function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
+    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }

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

@@ -1,13 +1,13 @@
 import { timeout } from '../../../utils/promise/timeout';
+import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
-import { isObject } from '../../../utils/lang';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache, notifyUpdate, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -19,27 +19,28 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, mySegmentsCache
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        if (isObject(segmentsData[0])) {
-            // Add/Delete the segment names
-            segmentsData.forEach(function (_a) {
-                var name = _a.name, add = _a.add;
-                if (mySegmentsCache.isInSegment(name) !== add) {
-                    shouldNotifyUpdate = true;
-                    if (add)
-                        mySegmentsCache.addToSegment(name);
-                    else
-                        mySegmentsCache.removeFromSegment(name);
-                }
-            });
+        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(SDK_SEGMENTS_ARRIVED);
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache) {

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

@@ -1,4 +1,4 @@
-import { endsWith, isString } from '../../../utils/lang';
+import { isString } from '../../../utils/lang';
 import { objectAssign } from '../../../utils/lang/objectAssign';
 var ABLY_API_VERSION = '1.1';
 var CONTROL_CHANNEL_REGEX = /^control_/;
@@ -44,7 +44,6 @@ var SSEClient = /** @class */ (function () {
         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;
@@ -56,13 +55,10 @@ var SSEClient = /** @class */ (function () {
      * @throws {TypeError} Will throw an error if `authToken` is undefined
      */
     SSEClient.prototype.open = function (authToken) {
-        var _this = this;
         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 || !endsWith(channel, 'myLargeSegments');
         }).join(',');
         var url = this.streamingUrl + "?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + ABLY_API_VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
         this.connection = new this.eventSource(