@splitsoftware/splitio-commons 2.0.1-rc.0 → 2.0.1

package/CHANGES.txt

@@ -1,5 +1,5 @@
-2.0.1 (XXX XX, 2024)
- - Updated the factory `init` and `destroy` methods to support re-initialization after destruction, enabling repeated cycles of initialization and cleanup. This update ensures compatibility of the React SDK with React Strict Mode, where the factory's `init` and `destroy` effects are executed an extra time to validate proper resource cleanup.
+2.0.1 (November 25, 2024)
+ - Bugfixing - Fixed an issue with the SDK_UPDATE event on server-side, where it was not being emitted if there was an empty segment and the SDK received a feature flag update notification.
 
 2.0.0 (November 1, 2024)
  - Added support for targeting rules based on large segments.

package/cjs/readiness/readinessManager.js

@@ -28,7 +28,7 @@ function segmentsEventEmitterFactory(EventEmitter) {
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
+function readinessManagerFactory(EventEmitter, settings, splits) {
     if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
     var readyTimeout = settings.startup.readyTimeout;
     var segments = segmentsEventEmitterFactory(EventEmitter);
@@ -54,24 +54,22 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
         syncLastUpdate();
         gate.emit(constants_1.SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
     }
+    var readyTimeoutId;
+    if (readyTimeout > 0) {
+        if (splits.hasInit)
+            readyTimeoutId = setTimeout(timeout, readyTimeout);
+        else
+            splits.initCallbacks.push(function () { readyTimeoutId = setTimeout(timeout, readyTimeout); });
+    }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
     splits.on(constants_1.SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
     segments.on(constants_1.SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
     var isDestroyed = false;
-    var readyTimeoutId;
-    function __init() {
-        isDestroyed = false;
-        if (readyTimeout > 0 && !isReady)
-            readyTimeoutId = setTimeout(timeout, readyTimeout);
-    }
-    splits.initCallbacks.push(__init);
-    if (splits.hasInit)
-        __init();
     function checkIsReadyFromCache() {
         isReadyFromCache = true;
         // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
-        if (!isReady && !isDestroyed) {
+        if (!isReady) {
             try {
                 syncLastUpdate();
                 gate.emit(constants_1.SDK_READY_FROM_CACHE);
@@ -83,8 +81,6 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
         }
     }
     function checkIsReadyOrUpdate(diff) {
-        if (isDestroyed)
-            return;
         if (isReady) {
             try {
                 syncLastUpdate();
@@ -110,12 +106,14 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
             }
         }
     }
+    var refCount = 1;
     return {
         splits: splits,
         segments: segments,
         gate: gate,
         shared: function () {
-            return readinessManagerFactory(EventEmitter, settings, splits, true);
+            refCount++;
+            return readinessManagerFactory(EventEmitter, settings, splits);
         },
         // @TODO review/remove next methods when non-recoverable errors are reworked
         // Called on consumer mode, when storage fails to connect
@@ -132,9 +130,13 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();
+            segments.removeAllListeners();
+            gate.removeAllListeners();
             clearTimeout(readyTimeoutId);
-            if (!isShared)
-                splits.hasInit = false;
+            if (refCount > 0)
+                refCount--;
+            if (refCount === 0)
+                splits.removeAllListeners();
         },
         isReady: function () { return isReady; },
         isReadyFromCache: function () { return isReadyFromCache; },

package/cjs/sdkFactory/index.js

@@ -102,7 +102,6 @@ function sdkFactory(params) {
         Logger: (0, sdkLogger_1.createLoggerAPI)(log),
         settings: settings,
         destroy: function () {
-            hasInit = false;
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
     }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());

package/cjs/storages/inLocalStorage/index.js

@@ -9,6 +9,8 @@ var KeyBuilderCS_1 = require("../KeyBuilderCS");
 var isLocalStorageAvailable_1 = require("../../utils/env/isLocalStorageAvailable");
 var SplitsCacheInLocal_1 = require("./SplitsCacheInLocal");
 var MySegmentsCacheInLocal_1 = require("./MySegmentsCacheInLocal");
+var MySegmentsCacheInMemory_1 = require("../inMemory/MySegmentsCacheInMemory");
+var SplitsCacheInMemory_1 = require("../inMemory/SplitsCacheInMemory");
 var browser_1 = require("../../utils/constants/browser");
 var InMemoryStorageCS_1 = require("../inMemory/InMemoryStorageCS");
 var constants_1 = require("./constants");
@@ -28,7 +30,7 @@ function InLocalStorage(options) {
             params.settings.log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
         }
-        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
         var matchingKey = (0, key_1.getMatching)(settings.core.key);
         var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - browser_1.DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
@@ -44,7 +46,16 @@ function InLocalStorage(options) {
             events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
             telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: impressionsMode === constants_2.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
-            destroy: function () { },
+            destroy: function () {
+                var _a;
+                this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
+                this.segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+                this.largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+                this.impressions.clear();
+                this.impressionCounts && this.impressionCounts.clear();
+                this.events.clear();
+                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
+            },
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
@@ -55,7 +66,11 @@ function InLocalStorage(options) {
                     impressionCounts: this.impressionCounts,
                     events: this.events,
                     telemetry: this.telemetry,
-                    destroy: function () { }
+                    destroy: function () {
+                        this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
+                        this.segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+                        this.largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+                    }
                 };
             },
         };

package/cjs/storages/inMemory/InMemoryStorage.js

@@ -26,7 +26,15 @@ function InMemoryStorageFactory(params) {
         events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
         telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : undefined,
-        destroy: function () { }
+        // When using MEMORY we should clean all the caches to leave them empty
+        destroy: function () {
+            this.splits.clear();
+            this.segments.clear();
+            this.impressions.clear();
+            this.impressionCounts && this.impressionCounts.clear();
+            this.events.clear();
+            this.uniqueKeys && this.uniqueKeys.clear();
+        }
     };
     // @TODO revisit storage logic in localhost mode
     // No tracking data in localhost mode to avoid memory leaks

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -28,7 +28,16 @@ function InMemoryStorageCSFactory(params) {
         events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
         telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
-        destroy: function () { },
+        // When using MEMORY we should clean all the caches to leave them empty
+        destroy: function () {
+            this.splits.clear();
+            this.segments.clear();
+            this.largeSegments.clear();
+            this.impressions.clear();
+            this.impressionCounts && this.impressionCounts.clear();
+            this.events.clear();
+            this.uniqueKeys && this.uniqueKeys.clear();
+        },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {
@@ -39,7 +48,12 @@ function InMemoryStorageCSFactory(params) {
                 impressionCounts: this.impressionCounts,
                 events: this.events,
                 telemetry: this.telemetry,
-                destroy: function () { }
+                // Set a new splits cache to clean it for the client without affecting other clients
+                destroy: function () {
+                    this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
+                    this.segments.clear();
+                    this.largeSegments.clear();
+                }
             };
         },
     };

package/cjs/storages/inMemory/SegmentsCacheInMemory.js

@@ -52,7 +52,7 @@ var SegmentsCacheInMemory = /** @class */ (function () {
     };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
-        return (0, lang_1.isIntegerNumber)(value) ? value : -1;
+        return (0, lang_1.isIntegerNumber)(value) ? value : undefined;
     };
     // No-op. Not used in server-side
     SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -31,10 +31,10 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
+            return (0, lang_1.isNaNNumber)(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     SegmentsCacheInRedis.prototype.registerSegments = function (segments) {

package/cjs/storages/pluggable/SegmentsCachePluggable.js

@@ -45,10 +45,10 @@ var SegmentsCachePluggable = /** @class */ (function () {
         var _this = this;
         return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
+            return (0, lang_1.isNaNNumber)(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     /**

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

@@ -21,9 +21,9 @@ 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
-            return fetchOnlyNew && since !== -1 ?
+            return fetchOnlyNew && since !== undefined ?
                 false :
-                segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+                segmentChangesFetcher(since || -1, 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(segmentName, x.added, x.removed, x.till);

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

@@ -14,7 +14,7 @@ function checkAllSegmentsExist(segments) {
     var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
     return registeredSegments.then(function (segmentNames) {
         return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== -1; }); });
+            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
     });
 }
 /**

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

@@ -16,7 +16,7 @@ function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
         var backoff = new Backoff_1.Backoff(__handleSegmentUpdateCall, constants_1.FETCH_BACKOFF_BASE, constants_1.FETCH_BACKOFF_MAX_WAIT);
         function __handleSegmentUpdateCall() {
             isHandlingEvent = true;
-            if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+            if (maxChangeNumber > (segmentsCache.getChangeNumber(segment) || -1)) {
                 handleNewEvent = false;
                 // fetch segments revalidating data if cached
                 segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(function () {
@@ -27,7 +27,7 @@ function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
                     }
                     else {
                         var attempts = backoff.attempts + 1;
-                        if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+                        if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
                             log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
                             isHandlingEvent = false;
                             return;
@@ -54,7 +54,7 @@ function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
         }
         return {
             put: function (changeNumber) {
-                var currentChangeNumber = segmentsCache.getChangeNumber(segment);
+                var currentChangeNumber = segmentsCache.getChangeNumber(segment) || -1;
                 if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
                     return;
                 maxChangeNumber = changeNumber;

package/esm/readiness/readinessManager.js

@@ -25,7 +25,7 @@ function segmentsEventEmitterFactory(EventEmitter) {
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
+export function readinessManagerFactory(EventEmitter, settings, splits) {
     if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
     var readyTimeout = settings.startup.readyTimeout;
     var segments = segmentsEventEmitterFactory(EventEmitter);
@@ -51,24 +51,22 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         syncLastUpdate();
         gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
     }
+    var readyTimeoutId;
+    if (readyTimeout > 0) {
+        if (splits.hasInit)
+            readyTimeoutId = setTimeout(timeout, readyTimeout);
+        else
+            splits.initCallbacks.push(function () { readyTimeoutId = setTimeout(timeout, readyTimeout); });
+    }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
     splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
     segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
     var isDestroyed = false;
-    var readyTimeoutId;
-    function __init() {
-        isDestroyed = false;
-        if (readyTimeout > 0 && !isReady)
-            readyTimeoutId = setTimeout(timeout, readyTimeout);
-    }
-    splits.initCallbacks.push(__init);
-    if (splits.hasInit)
-        __init();
     function checkIsReadyFromCache() {
         isReadyFromCache = true;
         // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
-        if (!isReady && !isDestroyed) {
+        if (!isReady) {
             try {
                 syncLastUpdate();
                 gate.emit(SDK_READY_FROM_CACHE);
@@ -80,8 +78,6 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         }
     }
     function checkIsReadyOrUpdate(diff) {
-        if (isDestroyed)
-            return;
         if (isReady) {
             try {
                 syncLastUpdate();
@@ -107,12 +103,14 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
             }
         }
     }
+    var refCount = 1;
     return {
         splits: splits,
         segments: segments,
         gate: gate,
         shared: function () {
-            return readinessManagerFactory(EventEmitter, settings, splits, true);
+            refCount++;
+            return readinessManagerFactory(EventEmitter, settings, splits);
         },
         // @TODO review/remove next methods when non-recoverable errors are reworked
         // Called on consumer mode, when storage fails to connect
@@ -129,9 +127,13 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();
+            segments.removeAllListeners();
+            gate.removeAllListeners();
             clearTimeout(readyTimeoutId);
-            if (!isShared)
-                splits.hasInit = false;
+            if (refCount > 0)
+                refCount--;
+            if (refCount === 0)
+                splits.removeAllListeners();
         },
         isReady: function () { return isReady; },
         isReadyFromCache: function () { return isReadyFromCache; },

package/esm/sdkFactory/index.js

@@ -99,7 +99,6 @@ export function sdkFactory(params) {
         Logger: createLoggerAPI(log),
         settings: settings,
         destroy: function () {
-            hasInit = false;
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
     }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());

package/esm/storages/inLocalStorage/index.js

@@ -6,6 +6,8 @@ import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
+import { MySegmentsCacheInMemory } from '../inMemory/MySegmentsCacheInMemory';
+import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
@@ -25,7 +27,7 @@ export function InLocalStorage(options) {
             params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return InMemoryStorageCSFactory(params);
         }
-        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
@@ -41,7 +43,16 @@ export function InLocalStorage(options) {
             events: new EventsCacheInMemory(eventsQueueSize),
             telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
-            destroy: function () { },
+            destroy: function () {
+                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();
+                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
+            },
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
@@ -52,7 +63,11 @@ export function InLocalStorage(options) {
                     impressionCounts: this.impressionCounts,
                     events: this.events,
                     telemetry: this.telemetry,
-                    destroy: function () { }
+                    destroy: function () {
+                        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+                        this.segments = new MySegmentsCacheInMemory();
+                        this.largeSegments = new MySegmentsCacheInMemory();
+                    }
                 };
             },
         };

package/esm/storages/inMemory/InMemoryStorage.js

@@ -23,7 +23,15 @@ export function InMemoryStorageFactory(params) {
         events: new EventsCacheInMemory(eventsQueueSize),
         telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
-        destroy: function () { }
+        // When using MEMORY we should clean all the caches to leave them empty
+        destroy: function () {
+            this.splits.clear();
+            this.segments.clear();
+            this.impressions.clear();
+            this.impressionCounts && this.impressionCounts.clear();
+            this.events.clear();
+            this.uniqueKeys && this.uniqueKeys.clear();
+        }
     };
     // @TODO revisit storage logic in localhost mode
     // No tracking data in localhost mode to avoid memory leaks

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -25,7 +25,16 @@ export function InMemoryStorageCSFactory(params) {
         events: new EventsCacheInMemory(eventsQueueSize),
         telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
         uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
-        destroy: function () { },
+        // When using MEMORY we should clean all the caches to leave them empty
+        destroy: function () {
+            this.splits.clear();
+            this.segments.clear();
+            this.largeSegments.clear();
+            this.impressions.clear();
+            this.impressionCounts && this.impressionCounts.clear();
+            this.events.clear();
+            this.uniqueKeys && this.uniqueKeys.clear();
+        },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {
@@ -36,7 +45,12 @@ export function InMemoryStorageCSFactory(params) {
                 impressionCounts: this.impressionCounts,
                 events: this.events,
                 telemetry: this.telemetry,
-                destroy: function () { }
+                // Set a new splits cache to clean it for the client without affecting other clients
+                destroy: function () {
+                    this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+                    this.segments.clear();
+                    this.largeSegments.clear();
+                }
             };
         },
     };

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -49,7 +49,7 @@ var SegmentsCacheInMemory = /** @class */ (function () {
     };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
-        return isIntegerNumber(value) ? value : -1;
+        return isIntegerNumber(value) ? value : undefined;
     };
     // No-op. Not used in server-side
     SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };

package/esm/storages/inRedis/SegmentsCacheInRedis.js

@@ -28,10 +28,10 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return isNaNNumber(i) ? -1 : i;
+            return isNaNNumber(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     SegmentsCacheInRedis.prototype.registerSegments = function (segments) {

package/esm/storages/pluggable/SegmentsCachePluggable.js

@@ -42,10 +42,10 @@ var SegmentsCachePluggable = /** @class */ (function () {
         var _this = this;
         return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return isNaNNumber(i) ? -1 : i;
+            return isNaNNumber(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     /**

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

@@ -18,9 +18,9 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
-            return fetchOnlyNew && since !== -1 ?
+            return fetchOnlyNew && since !== undefined ?
                 false :
-                segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+                segmentChangesFetcher(since || -1, segmentName, noCache, till).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
                         log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
                         return segments.update(segmentName, x.added, x.removed, x.till);

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

@@ -11,7 +11,7 @@ function checkAllSegmentsExist(segments) {
     var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
     return registeredSegments.then(function (segmentNames) {
         return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== -1; }); });
+            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
     });
 }
 /**

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

@@ -13,7 +13,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
         var backoff = new Backoff(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
         function __handleSegmentUpdateCall() {
             isHandlingEvent = true;
-            if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+            if (maxChangeNumber > (segmentsCache.getChangeNumber(segment) || -1)) {
                 handleNewEvent = false;
                 // fetch segments revalidating data if cached
                 segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(function () {
@@ -24,7 +24,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
                     }
                     else {
                         var attempts = backoff.attempts + 1;
-                        if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+                        if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
                             log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
                             isHandlingEvent = false;
                             return;
@@ -51,7 +51,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
         }
         return {
             put: function (changeNumber) {
-                var currentChangeNumber = segmentsCache.getChangeNumber(segment);
+                var currentChangeNumber = segmentsCache.getChangeNumber(segment) || -1;
                 if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
                     return;
                 maxChangeNumber = changeNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.0.1-rc.0",
+  "version": "2.0.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/readiness/readinessManager.ts

@@ -37,9 +37,7 @@ function segmentsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitt
 export function readinessManagerFactory(
   EventEmitter: new () => SplitIO.IEventEmitter,
   settings: ISettings,
-  splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter),
-  isShared?: boolean
-): IReadinessManager {
+  splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
   const readyTimeout = settings.startup.readyTimeout;
 
@@ -68,6 +66,11 @@ export function readinessManagerFactory(
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
   }
 
+  let readyTimeoutId: ReturnType<typeof setTimeout>;
+  if (readyTimeout > 0) {
+    if (splits.hasInit) readyTimeoutId = setTimeout(timeout, readyTimeout);
+    else splits.initCallbacks.push(() => { readyTimeoutId = setTimeout(timeout, readyTimeout); });
+  }
 
   // emit SDK_READY and SDK_UPDATE
   let isReady = false;
@@ -75,19 +78,11 @@ export function readinessManagerFactory(
   segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
 
   let isDestroyed = false;
-  let readyTimeoutId: ReturnType<typeof setTimeout>;
-  function __init() {
-    isDestroyed = false;
-    if (readyTimeout > 0 && !isReady) readyTimeoutId = setTimeout(timeout, readyTimeout);
-  }
-
-  splits.initCallbacks.push(__init);
-  if (splits.hasInit) __init();
 
   function checkIsReadyFromCache() {
     isReadyFromCache = true;
     // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
-    if (!isReady && !isDestroyed) {
+    if (!isReady) {
       try {
         syncLastUpdate();
         gate.emit(SDK_READY_FROM_CACHE);
@@ -99,7 +94,6 @@ export function readinessManagerFactory(
   }
 
   function checkIsReadyOrUpdate(diff: any) {
-    if (isDestroyed) return;
     if (isReady) {
       try {
         syncLastUpdate();
@@ -123,13 +117,16 @@ export function readinessManagerFactory(
     }
   }
 
+  let refCount = 1;
+
   return {
     splits,
     segments,
     gate,
 
     shared() {
-      return readinessManagerFactory(EventEmitter, settings, splits, true);
+      refCount++;
+      return readinessManagerFactory(EventEmitter, settings, splits);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked
@@ -148,9 +145,13 @@ export function readinessManagerFactory(
     destroy() {
       isDestroyed = true;
       syncLastUpdate();
+
+      segments.removeAllListeners();
+      gate.removeAllListeners();
       clearTimeout(readyTimeoutId);
 
-      if (!isShared) splits.hasInit = false;
+      if (refCount > 0) refCount--;
+      if (refCount === 0) splits.removeAllListeners();
     },
 
     isReady() { return isReady; },

package/src/sdkFactory/index.ts

@@ -126,7 +126,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     settings,
 
     destroy() {
-      hasInit = false;
       return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
   }, extraProps && extraProps(ctx), lazyInit ? { init } : init());

package/src/storages/AbstractMySegmentsCacheSync.ts

@@ -42,7 +42,7 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
   // @TODO for client-side it should be the number of clients, but it requires a refactor of MySegments caches to simplify the code.
   abstract getKeysCount(): number
 
-  abstract getChangeNumber(name: string): number
+  abstract getChangeNumber(): number
 
   /**
    * For server-side synchronizer: the method is not used.

package/src/storages/inLocalStorage/index.ts

@@ -7,6 +7,8 @@ import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
+import { MySegmentsCacheInMemory } from '../inMemory/MySegmentsCacheInMemory';
+import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
@@ -34,7 +36,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       return InMemoryStorageCSFactory(params);
     }
 
-    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
@@ -53,7 +55,15 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
       uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
-      destroy() { },
+      destroy() {
+        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+        this.segments = new MySegmentsCacheInMemory();
+        this.largeSegments = new MySegmentsCacheInMemory();
+        this.impressions.clear();
+        this.impressionCounts && this.impressionCounts.clear();
+        this.events.clear();
+        this.uniqueKeys?.clear();
+      },
 
       // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
@@ -67,7 +77,11 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           events: this.events,
           telemetry: this.telemetry,
 
-          destroy() { }
+          destroy() {
+            this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+            this.segments = new MySegmentsCacheInMemory();
+            this.largeSegments = new MySegmentsCacheInMemory();
+          }
         };
       },
     };

package/src/storages/inMemory/InMemoryStorage.ts

@@ -28,7 +28,15 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
     telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
     uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
 
-    destroy() { }
+    // When using MEMORY we should clean all the caches to leave them empty
+    destroy() {
+      this.splits.clear();
+      this.segments.clear();
+      this.impressions.clear();
+      this.impressionCounts && this.impressionCounts.clear();
+      this.events.clear();
+      this.uniqueKeys && this.uniqueKeys.clear();
+    }
   };
 
   // @TODO revisit storage logic in localhost mode

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -30,7 +30,16 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
     uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
-    destroy() { },
+    // When using MEMORY we should clean all the caches to leave them empty
+    destroy() {
+      this.splits.clear();
+      this.segments.clear();
+      this.largeSegments.clear();
+      this.impressions.clear();
+      this.impressionCounts && this.impressionCounts.clear();
+      this.events.clear();
+      this.uniqueKeys && this.uniqueKeys.clear();
+    },
 
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
@@ -43,7 +52,12 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         events: this.events,
         telemetry: this.telemetry,
 
-        destroy() { }
+        // Set a new splits cache to clean it for the client without affecting other clients
+        destroy() {
+          this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+          this.segments.clear();
+          this.largeSegments.clear();
+        }
       };
     },
   };

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -65,7 +65,7 @@ export class SegmentsCacheInMemory implements ISegmentsCacheSync {
   getChangeNumber(name: string) {
     const value = this.segmentChangeNumber[name];
 
-    return isIntegerNumber(value) ? value : -1;
+    return isIntegerNumber(value) ? value : undefined;
   }
 
   // No-op. Not used in server-side

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -44,10 +44,10 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     return this.redis.get(this.keys.buildSegmentTillKey(name)).then((value: string | null) => {
       const i = parseInt(value as string, 10);
 
-      return isNaNNumber(i) ? -1 : i;
+      return isNaNNumber(i) ? undefined : i;
     }).catch((e) => {
       this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-      return -1;
+      return undefined;
     });
   }
 

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -55,10 +55,10 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
     return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then((value: string | null) => {
       const i = parseInt(value as string, 10);
 
-      return isNaNNumber(i) ? -1 : i;
+      return isNaNNumber(i) ? undefined : i;
     }).catch((e) => {
       this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-      return -1;
+      return undefined;
     });
   }
 

package/src/storages/types.ts

@@ -237,7 +237,7 @@ export interface ISegmentsCacheBase {
   isInSegment(name: string, key?: string): MaybeThenable<boolean> // different signature on Server and Client-Side
   registerSegments(names: string[]): MaybeThenable<boolean | void> // only for Server-Side
   getRegisteredSegments(): MaybeThenable<string[]> // only for Server-Side
-  getChangeNumber(name: string): MaybeThenable<number> // only for Server-Side
+  getChangeNumber(name: string): MaybeThenable<number | undefined> // only for Server-Side
   update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean> // only for Server-Side
   clear(): MaybeThenable<boolean | void>
 }
@@ -248,7 +248,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
-  getChangeNumber(name?: string): number
+  getChangeNumber(name?: string): number | undefined
   update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean // only for Server-Side
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
@@ -258,7 +258,7 @@ export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
   isInSegment(name: string, key: string): Promise<boolean>
   registerSegments(names: string[]): Promise<boolean | void>
   getRegisteredSegments(): Promise<string[]>
-  getChangeNumber(name: string): Promise<number>
+  getChangeNumber(name: string): Promise<number | undefined>
   update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>
   clear(): Promise<boolean | void>
 }

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -33,9 +33,9 @@ export function segmentChangesUpdaterFactory(
 
     return sincePromise.then(since => {
       // if fetchOnlyNew flag, avoid processing already fetched segments
-      return fetchOnlyNew && since !== -1 ?
+      return fetchOnlyNew && since !== undefined ?
         false :
-        segmentChangesFetcher(since, segmentName, noCache, till).then((changes) => {
+        segmentChangesFetcher(since || -1, segmentName, noCache, till).then((changes) => {
           return Promise.all(changes.map(x => {
             log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
             return segments.update(segmentName, x.added, x.removed, x.till);

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -19,7 +19,7 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
   let registeredSegments = Promise.resolve(segments.getRegisteredSegments());
   return registeredSegments.then(segmentNames => {
     return Promise.all(segmentNames.map(segmentName => segments.getChangeNumber(segmentName)))
-      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== -1));
+      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== undefined));
   });
 }
 

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -3,10 +3,11 @@ import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { MEMBERSHIPS } from '../../../utils/constants';
-import { ISegmentsCacheSync, IStorageSync } from '../../../storages/types';
+import { IStorageSync } from '../../../storages/types';
 import { ILogger } from '../../../logger/types';
 import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
 import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
+import { AbstractMySegmentsCacheSync } from '../../../storages/AbstractMySegmentsCacheSync';
 
 /**
  * MySegmentsUpdateWorker factory
@@ -16,7 +17,7 @@ export function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync,
   let _delay: undefined | number;
   let _delayTimeoutID: any;
 
-  function createUpdateWorker(mySegmentsCache: ISegmentsCacheSync) {
+  function createUpdateWorker(mySegmentsCache: AbstractMySegmentsCacheSync) {
 
     let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
     let currentChangeNumber = -1;
@@ -117,8 +118,8 @@ export function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync,
   }
 
   const updateWorkers = {
-    [MEMBERSHIPS_MS_UPDATE]: createUpdateWorker(storage.segments),
-    [MEMBERSHIPS_LS_UPDATE]: createUpdateWorker(storage.largeSegments!),
+    [MEMBERSHIPS_MS_UPDATE]: createUpdateWorker(storage.segments as AbstractMySegmentsCacheSync),
+    [MEMBERSHIPS_LS_UPDATE]: createUpdateWorker(storage.largeSegments as AbstractMySegmentsCacheSync),
   };
 
   return {

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -21,7 +21,7 @@ export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSy
 
     function __handleSegmentUpdateCall() {
       isHandlingEvent = true;
-      if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+      if (maxChangeNumber > (segmentsCache.getChangeNumber(segment) || -1)) {
         handleNewEvent = false;
 
         // fetch segments revalidating data if cached
@@ -32,7 +32,7 @@ export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSy
           } else {
             const attempts = backoff.attempts + 1;
 
-            if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+            if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
               log.debug(`Refresh completed${cdnBypass ? ' bypassing the CDN' : ''} in ${attempts} attempts.`);
               isHandlingEvent = false;
               return;
@@ -60,7 +60,7 @@ export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSy
 
     return {
       put(changeNumber: number) {
-        const currentChangeNumber = segmentsCache.getChangeNumber(segment);
+        const currentChangeNumber = segmentsCache.getChangeNumber(segment) || -1;
 
         if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;