@splitsoftware/splitio-commons 2.0.0-rc.0 → 2.0.0-rc.1

package/CHANGES.txt

@@ -1,15 +1,16 @@
 2.0.0 (October XX, 2024)
  - Added support for targeting rules based on large segments.
  - Added `factory.destroy()` method, which invokes the `destroy` method on all SDK clients created by the factory.
+ - Updated the handling of timers and async operations inside an `init` factory method to enable lazy initialization of the SDK in standalone mode. This update is intended for the React SDK.
  - Bugfixing - Fixed an issue with the server-side polling manager that caused dangling timers when the SDK was destroyed before it was ready.
  - BREAKING CHANGES:
    - Updated default flag spec version to 1.2.
    - Removed `/mySegments` endpoint from SplitAPI module, as it is replaced by `/memberships` endpoint.
    - Removed support for MY_SEGMENTS_UPDATE and MY_SEGMENTS_UPDATE_V2 notification types, as they are replaced by MEMBERSHIPS_MS_UPDATE and MEMBERSHIPS_LS_UPDATE notification types.
    - Removed the deprecated `GOOGLE_ANALYTICS_TO_SPLIT` and `SPLIT_TO_GOOGLE_ANALYTICS` integrations.
-   - Removed internal ponyfills for `Map`, `Set` and `Array.from` global objects, dropping support for IE and other outdated browsers. The SDK now requires the runtime environment to support these features natively or to provide a polyfill.
    - Removed the migration logic for the old format of MySegments keys in LocalStorage introduced in JavaScript SDK v10.17.3.
    - Removed the `sdkClientMethodCSWithTT` function, which handled the logic to bound an optional traffic type to SDK clients. Client-side SDK implementations must use `sdkClientMethodCS` module, which, unlike the previous function, does not allow passing a traffic type but simplifies the SDK API.
+   - Removed internal ponyfills for `Map` and `Set` global objects, dropping support for IE and other outdated browsers. The SDK now requires the runtime environment to support these features natively or to provide a polyfill.
 
 1.17.0 (September 6, 2024)
  - Added `sync.requestOptions.getHeaderOverrides` configuration option to enhance SDK HTTP request Headers for Authorization Frameworks.

package/cjs/evaluator/Engine.js

@@ -17,7 +17,7 @@ var Engine = /** @class */ (function () {
     function Engine(baseInfo, evaluator) {
         this.baseInfo = baseInfo;
         this.evaluator = evaluator;
-        // in case we don't have a default treatment in the instanciation, use 'control'
+        // in case we don't have a default treatment in the instantiation, use 'control'
         if (typeof this.baseInfo.defaultTreatment !== 'string') {
             this.baseInfo.defaultTreatment = constants_1.CONTROL;
         }

package/cjs/evaluator/index.js

@@ -70,7 +70,7 @@ function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, met
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, Array.from(featureFlags), attributes, storage) :
+            evaluateFeatures(log, key, (0, sets_1.setToArray)(featureFlags), attributes, storage) :
             {};
     }
     // get features by flag sets

package/cjs/readiness/readinessManager.js

@@ -7,6 +7,8 @@ function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = (0, objectAssign_1.objectAssign)(new EventEmitter(), {
         splitsArrived: false,
         splitsCacheLoaded: false,
+        initialized: false,
+        initCallbacks: []
     });
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
     // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
@@ -46,7 +48,7 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
-        if (hasTimedout)
+        if (hasTimedout || isReady)
             return;
         hasTimedout = true;
         syncLastUpdate();
@@ -54,7 +56,10 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
     }
     var readyTimeoutId;
     if (readyTimeout > 0) {
-        readyTimeoutId = setTimeout(timeout, readyTimeout);
+        if (splits.initialized)
+            readyTimeoutId = setTimeout(timeout, readyTimeout);
+        else
+            splits.initCallbacks.push(function () { readyTimeoutId = setTimeout(timeout, readyTimeout); });
     }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
@@ -116,6 +121,12 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
         // Called on 403 error (client-side SDK key on server-side), to set the SDK as destroyed for
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
+        init: function () {
+            if (splits.initialized)
+                return;
+            splits.initialized = true;
+            splits.initCallbacks.forEach(function (cb) { return cb(); });
+        },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();

package/cjs/sdkClient/sdkClientMethodCS.js

@@ -55,7 +55,6 @@ function sdkClientMethodCSFactory(params) {
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
             }), true), validKey);
-            sharedSyncManager && sharedSyncManager.start();
             log.info(constants_1.NEW_SHARED_CLIENT);
         }
         else {

package/cjs/sdkFactory/index.js

@@ -19,12 +19,19 @@ var constants_3 = require("../utils/constants");
  * Modular SDK factory
  */
 function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
     var log = settings.log, impressionsMode = settings.sync.impressionsMode;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
+    // initialization
+    var hasInit = false;
+    var initCallbacks = [];
+    function whenInit(cb) {
+        if (hasInit)
+            cb();
+        else
+            initCallbacks.push(cb);
+    }
     var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -56,8 +63,8 @@ function sdkFactory(params) {
         default:
             strategy = (0, strategyDebug_1.strategyDebugFactory)(observer);
     }
-    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
+    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
     var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
@@ -68,8 +75,19 @@ function sdkFactory(params) {
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
+    function init() {
+        if (hasInit)
+            return;
+        hasInit = true;
+        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+        (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
+        readiness.init();
+        uniqueKeysTracker && uniqueKeysTracker.start();
+        syncManager && syncManager.start();
+        signalListener && signalListener.start();
+        initCallbacks.forEach(function (cb) { return cb(); });
+        initCallbacks.length = 0;
+    }
     log.info(constants_1.NEW_FACTORY);
     // @ts-ignore
     return (0, objectAssign_1.objectAssign)({
@@ -86,6 +104,6 @@ function sdkFactory(params) {
         destroy: function () {
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
-    }, extraProps && extraProps(ctx));
+    }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());
 }
 exports.sdkFactory = sdkFactory;

package/cjs/storages/{AbstractSegmentsCacheSync.js → AbstractMySegmentsCacheSync.js}

@@ -1,39 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSegmentsCacheSync = void 0;
+exports.AbstractMySegmentsCacheSync = void 0;
 /**
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-var AbstractSegmentsCacheSync = /** @class */ (function () {
-    function AbstractSegmentsCacheSync() {
+var AbstractMySegmentsCacheSync = /** @class */ (function () {
+    function AbstractMySegmentsCacheSync() {
     }
     /**
      * clear the cache.
      */
-    AbstractSegmentsCacheSync.prototype.clear = function () {
+    AbstractMySegmentsCacheSync.prototype.clear = function () {
         this.resetSegments({});
     };
-    /**
-     * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
-     * For client-side synchronizer: the method is not used.
-     */
-    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
+    // No-op. Not used in client-side.
+    AbstractMySegmentsCacheSync.prototype.registerSegments = function () { return false; };
+    AbstractMySegmentsCacheSync.prototype.update = function () { return false; };
     /**
      * For server-side synchronizer: the method is not used.
      * For client-side synchronizer: it resets or updates the cache.
      */
-    AbstractSegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
+    AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
-        this.setChangeNumber(undefined, segmentsData.cn);
+        this.setChangeNumber(segmentsData.cn);
         var _a = segmentsData, added = _a.added, removed = _a.removed;
         if (added && removed) {
             var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff_1 = _this.addToSegment(segment) || isDiff_1;
+                isDiff_1 = _this.addSegment(segment) || isDiff_1;
             });
             removed.forEach(function (segment) {
-                isDiff_1 = _this.removeFromSegment(segment) || isDiff_1;
+                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
             });
             return isDiff_1;
         }
@@ -50,13 +48,13 @@ var AbstractSegmentsCacheSync = /** @class */ (function () {
             return false;
         // Slowest path => add and/or remove segments
         for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-            this.removeFromSegment(storedSegmentKeys[removeIndex]);
+            this.removeSegment(storedSegmentKeys[removeIndex]);
         }
         for (var addIndex = index; addIndex < names.length; addIndex++) {
-            this.addToSegment(names[addIndex]);
+            this.addSegment(names[addIndex]);
         }
         return true;
     };
-    return AbstractSegmentsCacheSync;
+    return AbstractMySegmentsCacheSync;
 }());
-exports.AbstractSegmentsCacheSync = AbstractSegmentsCacheSync;
+exports.AbstractMySegmentsCacheSync = AbstractMySegmentsCacheSync;

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsCacheInLocal = void 0;
 var tslib_1 = require("tslib");
 var lang_1 = require("../../utils/lang");
-var AbstractSegmentsCacheSync_1 = require("../AbstractSegmentsCacheSync");
+var AbstractMySegmentsCacheSync_1 = require("../AbstractMySegmentsCacheSync");
 var constants_1 = require("./constants");
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(MySegmentsCacheInLocal, _super);
@@ -14,7 +14,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
-    MySegmentsCacheInLocal.prototype.addToSegment = function (name) {
+    MySegmentsCacheInLocal.prototype.addSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
             if (localStorage.getItem(segmentKey) === constants_1.DEFINED)
@@ -27,7 +27,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             return false;
         }
     };
-    MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
+    MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
             if (localStorage.getItem(segmentKey) !== constants_1.DEFINED)
@@ -56,7 +56,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
     };
-    MySegmentsCacheInLocal.prototype.setChangeNumber = function (name, changeNumber) {
+    MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
             if (changeNumber)
                 localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
@@ -77,5 +77,5 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return n;
     };
     return MySegmentsCacheInLocal;
-}(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));
+}(AbstractMySegmentsCacheSync_1.AbstractMySegmentsCacheSync));
 exports.MySegmentsCacheInLocal = MySegmentsCacheInLocal;

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -6,6 +6,7 @@ var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
 var constants_1 = require("./constants");
 var KeyBuilder_1 = require("../KeyBuilder");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -243,7 +244,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
             var flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
             flagSetCache.add(featureFlag.name);
-            localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
+            localStorage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
         });
     };
     SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
@@ -265,7 +266,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             localStorage.removeItem(flagSetKey);
             return;
         }
-        localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
+        localStorage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
     };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync_1.AbstractSplitsCacheSync));

package/cjs/storages/inLocalStorage/index.js

@@ -56,7 +56,7 @@ function InLocalStorage(options) {
                 this.events.clear();
                 (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
             },
-            // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
+            // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
                     splits: this.splits,

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -38,7 +38,7 @@ function InMemoryStorageCSFactory(params) {
             this.events.clear();
             this.uniqueKeys && this.uniqueKeys.clear();
         },
-        // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
+        // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {
                 splits: this.splits,
@@ -58,7 +58,7 @@ function InMemoryStorageCSFactory(params) {
         },
     };
     // @TODO revisit storage logic in localhost mode
-    // No tracking data in localhost mode to avoid memory leaks
+    // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
     if (params.settings.mode === constants_1.LOCALHOST_MODE) {
         var noopTrack = function () { return true; };
         storage.impressions.track = noopTrack;

package/cjs/storages/inMemory/MySegmentsCacheInMemory.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsCacheInMemory = void 0;
 var tslib_1 = require("tslib");
-var AbstractSegmentsCacheSync_1 = require("../AbstractSegmentsCacheSync");
+var AbstractMySegmentsCacheSync_1 = require("../AbstractMySegmentsCacheSync");
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
@@ -14,13 +14,13 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
-    MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
+    MySegmentsCacheInMemory.prototype.addSegment = function (name) {
         if (this.segmentCache[name])
             return false;
         this.segmentCache[name] = true;
         return true;
     };
-    MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
+    MySegmentsCacheInMemory.prototype.removeSegment = function (name) {
         if (!this.segmentCache[name])
             return false;
         delete this.segmentCache[name];
@@ -29,7 +29,7 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    MySegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
+    MySegmentsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
         this.cn = changeNumber;
     };
     MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
@@ -42,5 +42,5 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         return 1;
     };
     return MySegmentsCacheInMemory;
-}(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));
+}(AbstractMySegmentsCacheSync_1.AbstractMySegmentsCacheSync));
 exports.MySegmentsCacheInMemory = MySegmentsCacheInMemory;

package/cjs/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,34 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentsCacheInMemory = void 0;
-var tslib_1 = require("tslib");
-var AbstractSegmentsCacheSync_1 = require("../AbstractSegmentsCacheSync");
 var lang_1 = require("../../utils/lang");
 /**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
+ * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
  */
-var SegmentsCacheInMemory = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(SegmentsCacheInMemory, _super);
+var SegmentsCacheInMemory = /** @class */ (function () {
     function SegmentsCacheInMemory() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.segmentCache = {};
-        _this.segmentChangeNumber = {};
-        return _this;
+        this.segmentCache = {};
+        this.segmentChangeNumber = {};
     }
-    SegmentsCacheInMemory.prototype.addToSegment = function (name, segmentKeys) {
-        var values = this.segmentCache[name];
-        var keySet = values ? values : new Set();
-        segmentKeys.forEach(function (k) { return keySet.add(k); });
-        this.segmentCache[name] = keySet;
-        return true;
-    };
-    SegmentsCacheInMemory.prototype.removeFromSegment = function (name, segmentKeys) {
-        var values = this.segmentCache[name];
-        var keySet = values ? values : new Set();
-        segmentKeys.forEach(function (k) { return keySet.delete(k); });
+    SegmentsCacheInMemory.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
+        var keySet = this.segmentCache[name] || new Set();
+        addedKeys.forEach(function (k) { return keySet.add(k); });
+        removedKeys.forEach(function (k) { return keySet.delete(k); });
         this.segmentCache[name] = keySet;
-        return true;
+        this.segmentChangeNumber[name] = changeNumber;
+        return addedKeys.length > 0 || removedKeys.length > 0;
     };
     SegmentsCacheInMemory.prototype.isInSegment = function (name, key) {
         var segmentValues = this.segmentCache[name];
@@ -62,14 +50,12 @@ var SegmentsCacheInMemory = /** @class */ (function (_super) {
             return acum + _this.segmentCache[segmentName].size;
         }, 0);
     };
-    SegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
-        this.segmentChangeNumber[name] = changeNumber;
-        return true;
-    };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
         return (0, lang_1.isIntegerNumber)(value) ? value : -1;
     };
+    // No-op. Not used in server-side
+    SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };
     return SegmentsCacheInMemory;
-}(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));
+}());
 exports.SegmentsCacheInMemory = SegmentsCacheInMemory;

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -6,7 +6,6 @@ var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(SplitsCacheInMemory, _super);

package/cjs/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueKeysCacheInMemory = exports.fromUniqueKeysCollector = void 0;
 var constants_1 = require("../inRedis/constants");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * Converts `uniqueKeys` data from cache into request payload for SS.
  */
@@ -10,7 +11,7 @@ function fromUniqueKeysCollector(uniqueKeys) {
     var featureNames = Object.keys(uniqueKeys);
     for (var i = 0; i < featureNames.length; i++) {
         var featureName = featureNames[i];
-        var userKeys = Array.from(uniqueKeys[featureName]);
+        var userKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
         var uniqueKeysPayload = {
             f: featureName,
             ks: userKeys

package/cjs/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueKeysCacheInMemoryCS = void 0;
 var constants_1 = require("../inRedis/constants");
+var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
     /**
      *
@@ -61,7 +62,7 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
         var userKeys = Object.keys(uniqueKeys);
         for (var k = 0; k < userKeys.length; k++) {
             var userKey = userKeys[k];
-            var featureNames = Array.from(uniqueKeys[userKey]);
+            var featureNames = (0, sets_1.setToArray)(uniqueKeys[userKey]);
             var uniqueKeysPayload = {
                 k: userKey,
                 fs: featureNames

package/cjs/storages/inRedis/RedisAdapter.js

@@ -6,6 +6,7 @@ var ioredis_1 = (0, tslib_1.__importDefault)(require("ioredis"));
 var lang_1 = require("../../utils/lang");
 var thenable_1 = require("../../utils/promise/thenable");
 var timeout_1 = require("../../utils/promise/timeout");
+var sets_1 = require("../../utils/lang/sets");
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
 var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw'];
@@ -128,7 +129,7 @@ var RedisAdapter = /** @class */ (function (_super) {
             setTimeout(function deferredDisconnect() {
                 if (instance._runningCommands.size > 0) {
                     instance.log.info(LOG_PREFIX + ("Attempting to disconnect but there are " + instance._runningCommands.size + " commands still waiting for resolution. Defering disconnection until those finish."));
-                    Promise.all(Array.from(instance._runningCommands))
+                    Promise.all((0, sets_1.setToArray)(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
                         originalMethod.apply(instance, params);

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -9,30 +9,24 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         this.redis = redis;
         this.keys = keys;
     }
-    SegmentsCacheInRedis.prototype.addToSegment = function (name, segmentKeys) {
+    /**
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., Redis operation fails).
+     */
+    SegmentsCacheInRedis.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.redis.sadd(segmentKey, segmentKeys).then(function () { return true; });
-        }
-        else {
-            return Promise.resolve(true);
-        }
-    };
-    SegmentsCacheInRedis.prototype.removeFromSegment = function (name, segmentKeys) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.redis.srem(segmentKey, segmentKeys).then(function () { return true; });
-        }
-        else {
-            return Promise.resolve(true);
-        }
+        return Promise.all([
+            addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
+            removedKeys.length && this.redis.srem(segmentKey, removedKeys),
+            this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+        ]).then(function () {
+            return addedKeys.length > 0 || removedKeys.length > 0;
+        });
     };
     SegmentsCacheInRedis.prototype.isInSegment = function (name, key) {
         return this.redis.sismember(this.keys.buildSegmentNameKey(name), key).then(function (matches) { return matches !== 0; });
     };
-    SegmentsCacheInRedis.prototype.setChangeNumber = function (name, changeNumber) {
-        return this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '').then(function (status) { return status === 'OK'; });
-    };
     SegmentsCacheInRedis.prototype.getChangeNumber = function (name) {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {

package/cjs/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
 var constants_1 = require("./constants");
 var constants_2 = require("./constants");
+var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(UniqueKeysCacheInRedis, _super);
     function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
@@ -24,7 +25,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = (0, sets_1.setToArray)(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/cjs/storages/pluggable/SegmentsCachePluggable.js

@@ -15,32 +15,19 @@ var SegmentsCachePluggable = /** @class */ (function () {
         this.wrapper = wrapper;
     }
     /**
-     * Add a list of `segmentKeys` to the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
-     */
-    SegmentsCachePluggable.prototype.addToSegment = function (name, segmentKeys) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.addItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
-    };
-    /**
-     * Remove a list of `segmentKeys` from the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., wrapper operation fails).
      */
-    SegmentsCachePluggable.prototype.removeFromSegment = function (name, segmentKeys) {
+    SegmentsCachePluggable.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.removeItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
+        return Promise.all([
+            addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
+            removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
+            this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+        ]).then(function () {
+            return addedKeys.length > 0 || removedKeys.length > 0;
+        });
     };
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
@@ -49,14 +36,6 @@ var SegmentsCachePluggable = /** @class */ (function () {
     SegmentsCachePluggable.prototype.isInSegment = function (name, key) {
         return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
     };
-    /**
-     * Set till number for the given segment `name`.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SegmentsCachePluggable.prototype.setChangeNumber = function (name, changeNumber) {
-        return this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '');
-    };
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.

package/cjs/storages/pluggable/UniqueKeysCachePluggable.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
 var constants_1 = require("../inRedis/constants");
 var constants_2 = require("./constants");
+var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCachePluggable = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(UniqueKeysCachePluggable, _super);
     function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
@@ -24,7 +25,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = (0, sets_1.setToArray)(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys