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

package/cjs/storages/pluggable/inMemoryWrapper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inMemoryWrapperFactory = void 0;
 var lang_1 = require("../../utils/lang");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
@@ -118,7 +119,7 @@ function inMemoryWrapperFactory(connDelay) {
             if (!set)
                 return Promise.resolve([]);
             if (set instanceof Set)
-                return Promise.resolve(Array.from(set));
+                return Promise.resolve((0, sets_1.setToArray)(set));
             return Promise.reject('key is not a set');
         },
         // always connects and disconnects

package/cjs/sync/offline/syncManagerOffline.js

@@ -19,23 +19,30 @@ function syncManagerOfflineFactory(splitsParserFactory) {
      */
     return function (_a) {
         var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        return (0, objectAssign_1.objectAssign)((0, fromObjectSyncTask_1.fromObjectSyncTaskFactory)(splitsParserFactory(), storage, readiness, settings), {
+        var mainSyncManager = (0, fromObjectSyncTask_1.fromObjectSyncTaskFactory)(splitsParserFactory(), storage, readiness, settings);
+        var mainStart = mainSyncManager.start;
+        var sharedStarts = [];
+        return (0, objectAssign_1.objectAssign)(mainSyncManager, {
+            start: function () {
+                mainStart();
+                sharedStarts.forEach(function (cb) { return cb(); });
+                sharedStarts.length = 0;
+            },
             // fake flush, that resolves immediately
             flush: flush,
             // [Only used for client-side]
             shared: function (matchingKey, readinessManager) {
+                // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
+                // SDK_READY cannot be emitted directly because this will not update the readiness status
+                function emitSdkReady() {
+                    readinessManager.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
+                }
+                if (mainSyncManager.isRunning())
+                    setTimeout(emitSdkReady);
+                else
+                    sharedStarts.push(emitSdkReady);
                 return {
-                    start: function () {
-                        // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-                        // SDK_READY cannot be emitted directly because this will not update the readiness status
-                        setTimeout(function () {
-                            readinessManager.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-                        }, 0);
-                    },
                     stop: function () { },
-                    isRunning: function () {
-                        return true;
-                    },
                     flush: flush,
                 };
             }

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

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentChangesUpdaterFactory = void 0;
-var lang_1 = require("../../../utils/lang");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
-var thenable_1 = require("../../../utils/promise/thenable");
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -23,27 +21,16 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
-            if (fetchOnlyNew && since !== -1)
-                return -1;
-            return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
-                var changeNumber = -1;
-                var results = [];
-                changes.forEach(function (x) {
-                    if (x.added.length > 0)
-                        results.push(segments.addToSegment(segmentName, x.added));
-                    if (x.removed.length > 0)
-                        results.push(segments.removeFromSegment(segmentName, x.removed));
-                    if (x.added.length > 0 || x.removed.length > 0) {
-                        results.push(segments.setChangeNumber(segmentName, x.till));
-                        changeNumber = x.till;
-                    }
-                    log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+            return fetchOnlyNew && since !== -1 ?
+                false :
+                segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+                    return Promise.all(changes.map(function (x) {
+                        log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+                        return segments.update(x.name, x.added, x.removed, x.till);
+                    })).then(function (updates) {
+                        return updates.some(function (update) { return update; });
+                    });
                 });
-                // If at least one storage operation result is a promise, join all in a single promise.
-                if (results.some(function (result) { return (0, thenable_1.thenable)(result); }))
-                    return Promise.all(results).then(function () { return changeNumber; });
-                return changeNumber;
-            });
         });
     }
     /**
@@ -62,14 +49,11 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            // Async fetchers are collected here.
-            var updaters = [];
-            for (var index = 0; index < segmentNames.length; index++) {
-                updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
-            }
+            // Async fetchers
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
-                if ((0, lang_1.findIndex)(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
+                if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
                     if (readiness)
                         readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);

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

@@ -6,6 +6,7 @@ var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var lang_1 = require("../../../utils/lang");
 var constants_3 = require("../../../utils/constants");
+var sets_1 = require("../../../utils/lang/sets");
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -71,7 +72,7 @@ function computeSplitsMutation(entries, filters) {
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
-    computed.segments = Array.from(segments);
+    computed.segments = (0, sets_1.setToArray)(segments);
     return computed;
 }
 exports.computeSplitsMutation = computeSplitsMutation;

package/cjs/sync/syncManagerOnline.js

@@ -118,33 +118,32 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 if (!pollingManager)
                     return;
                 var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
-                return {
-                    isRunning: mySegmentsSyncTask.isRunning,
-                    start: function () {
-                        if (syncEnabled) {
-                            if (pushManager) {
-                                if (pollingManager.isRunning()) {
-                                    // if doing polling, we must start the periodic fetch of data
-                                    if (storage.splits.usesSegments())
-                                        mySegmentsSyncTask.start();
-                                }
-                                else {
-                                    // if not polling, we must execute the sync task for the initial fetch
-                                    // of segments since `syncAll` was already executed when starting the main client
-                                    mySegmentsSyncTask.execute();
-                                }
-                                pushManager.add(matchingKey, mySegmentsSyncTask);
-                            }
-                            else {
+                if (running) {
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            if (pollingManager.isRunning()) {
+                                // if doing polling, we must start the periodic fetch of data
                                 if (storage.splits.usesSegments())
                                     mySegmentsSyncTask.start();
                             }
+                            else {
+                                // if not polling, we must execute the sync task for the initial fetch
+                                // of segments since `syncAll` was already executed when starting the main client
+                                mySegmentsSyncTask.execute();
+                            }
+                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
-                            if (!readinessManager.isReady())
-                                mySegmentsSyncTask.execute();
+                            if (storage.splits.usesSegments())
+                                mySegmentsSyncTask.start();
                         }
-                    },
+                    }
+                    else {
+                        if (!readinessManager.isReady())
+                            mySegmentsSyncTask.execute();
+                    }
+                }
+                return {
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
                         var mySegmentsSyncTask = pollingManager.get(matchingKey);

package/cjs/trackers/eventTracker.js

@@ -12,7 +12,7 @@ var mode_1 = require("../utils/settingsValidation/mode");
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
+function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -22,15 +22,17 @@ function eventTrackerFactory(settings, eventsCache, integrationsManager, telemet
         if (tracked) {
             log.info(constants_1.EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
-                // Wrap in a timeout because we don't want it to be blocking.
-                setTimeout(function () {
-                    // copy of event, to avoid unexpected behaviour if modified by integrations
-                    var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
-                    if (properties)
-                        eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, properties);
-                    // integrationsManager does not throw errors (they are internally handled by each integration module)
-                    integrationsManager.handleEvent(eventDataCopy);
-                }, 0);
+                whenInit(function () {
+                    // Wrap in a timeout because we don't want it to be blocking.
+                    setTimeout(function () {
+                        // copy of event, to avoid unexpected behaviour if modified by integrations
+                        var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
+                        if (properties)
+                            eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, properties);
+                        // integrationsManager does not throw errors (they are internally handled by each integration module)
+                        integrationsManager.handleEvent(eventDataCopy);
+                    });
+                });
             }
         }
         else {

package/cjs/trackers/impressionsTracker.js

@@ -14,7 +14,7 @@ var constants_2 = require("../utils/constants");
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -53,19 +53,21 @@ function impressionsTrackerFactory(settings, impressionsCache, strategy, integra
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    // Wrap in a timeout because we don't want it to be blocking.
-                    setTimeout(function () {
-                        // integrationsManager.handleImpression does not throw errors
-                        if (integrationsManager)
-                            integrationsManager.handleImpression(impressionData);
-                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                            if (impressionListener)
-                                impressionListener.logImpression(impressionData);
-                        }
-                        catch (err) {
-                            log.error(constants_1.ERROR_IMPRESSIONS_LISTENER, [err]);
-                        }
-                    }, 0);
+                    whenInit(function () {
+                        // Wrap in a timeout because we don't want it to be blocking.
+                        setTimeout(function () {
+                            // integrationsManager.handleImpression does not throw errors
+                            if (integrationsManager)
+                                integrationsManager.handleImpression(impressionData);
+                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                                if (impressionListener)
+                                    impressionListener.logImpression(impressionData);
+                            }
+                            catch (err) {
+                                log.error(constants_1.ERROR_IMPRESSIONS_LISTENER, [err]);
+                            }
+                        });
+                    });
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/cjs/trackers/uniqueKeysTracker.js

@@ -19,9 +19,6 @@ var noopFilterAdapter = {
 function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
-    if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -30,6 +27,11 @@ function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
+        start: function () {
+            if (filterAdapter.refreshRate) {
+                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+            }
+        },
         stop: function () {
             clearInterval(intervalId);
         }

package/cjs/utils/lang/sets.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.returnDifference = exports.returnSetsUnion = void 0;
+exports.returnDifference = exports.returnSetsUnion = exports.setToArray = void 0;
+function setToArray(set) {
+    if (Array.from)
+        return Array.from(set);
+    var array = [];
+    set.forEach(function (value) {
+        array.push(value);
+    });
+    return array;
+}
+exports.setToArray = setToArray;
 function returnSetsUnion(set, set2) {
-    return new Set(Array.from(set).concat(Array.from(set2)));
+    return new Set(setToArray(set).concat(setToArray(set2)));
 }
 exports.returnSetsUnion = returnSetsUnion;
 function returnDifference(list, list2) {

package/esm/evaluator/Engine.js

@@ -14,7 +14,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 = CONTROL;
         }

package/esm/evaluator/index.js

@@ -2,7 +2,7 @@ import { Engine } from './Engine';
 import { thenable } from '../utils/promise/thenable';
 import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
-import { returnSetsUnion } from '../utils/lang/sets';
+import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 var treatmentException = {
     treatment: CONTROL,
@@ -65,7 +65,7 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, Array.from(featureFlags), attributes, storage) :
+            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
             {};
     }
     // get features by flag sets

package/esm/readiness/readinessManager.js

@@ -4,6 +4,8 @@ function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = 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
@@ -43,7 +45,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
-        if (hasTimedout)
+        if (hasTimedout || isReady)
             return;
         hasTimedout = true;
         syncLastUpdate();
@@ -51,7 +53,10 @@ export 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;
@@ -113,6 +118,12 @@ export 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/esm/sdkClient/sdkClientMethodCS.js

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

package/esm/sdkFactory/index.js

@@ -16,12 +16,19 @@ import { NONE, OPTIMIZED } from '../utils/constants';
  * Modular SDK factory
  */
 export 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.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
+    // initialization
+    var hasInit = false;
+    var initCallbacks = [];
+    function whenInit(cb) {
+        if (hasInit)
+            cb();
+        else
+            initCallbacks.push(cb);
+    }
     var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -53,8 +60,8 @@ export function sdkFactory(params) {
         default:
             strategy = strategyDebugFactory(observer);
     }
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+    var eventTracker = 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 };
@@ -65,8 +72,19 @@ export 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.
+        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(NEW_FACTORY);
     // @ts-ignore
     return objectAssign({
@@ -83,5 +101,5 @@ export 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());
 }

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

@@ -2,35 +2,33 @@
  * 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;
         }
@@ -47,13 +45,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;
 }());
-export { AbstractSegmentsCacheSync };
+export { AbstractMySegmentsCacheSync };

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -1,6 +1,6 @@
 import { __extends } from "tslib";
 import { isNaNNumber } from '../../utils/lang';
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     __extends(MySegmentsCacheInLocal, _super);
@@ -11,7 +11,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) === DEFINED)
@@ -24,7 +24,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) !== DEFINED)
@@ -53,7 +53,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 + '');
@@ -74,5 +74,5 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return n;
     };
     return MySegmentsCacheInLocal;
-}(AbstractSegmentsCacheSync));
+}(AbstractMySegmentsCacheSync));
 export { MySegmentsCacheInLocal };

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -3,6 +3,7 @@ import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSyn
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { getStorageHash } from '../KeyBuilder';
+import { setToArray } from '../../utils/lang/sets';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -240,7 +241,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(setToArray(flagSetCache)));
         });
     };
     SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
@@ -262,7 +263,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             localStorage.removeItem(flagSetKey);
             return;
         }
-        localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
+        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
     };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync));

package/esm/storages/inLocalStorage/index.js

@@ -53,7 +53,7 @@ export 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/esm/storages/inMemory/InMemoryStorageCS.js

@@ -35,7 +35,7 @@ export 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,
@@ -55,7 +55,7 @@ export 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 === LOCALHOST_MODE) {
         var noopTrack = function () { return true; };
         storage.impressions.track = noopTrack;