@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.4

package/CHANGES.txt

@@ -1,7 +1,8 @@
-2.0.0 (September XX, 2024)
- - Updated internal storage factory to emit the SDK_READY_FROM_CACHE event when it corresponds, to clean up the initialization flow.
- - Added `factory.destroy()` method, which invokes the `destroy` method on all SDK clients created by the factory.
+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.

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
@@ -45,7 +47,6 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
         splits.once(constants_1.SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
-    var readyTimeoutId;
     function timeout() {
         if (hasTimedout || isReady)
             return;
@@ -53,6 +54,13 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
         syncLastUpdate();
         gate.emit(constants_1.SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
     }
+    var readyTimeoutId;
+    if (readyTimeout > 0) {
+        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;
     splits.on(constants_1.SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
@@ -114,9 +122,10 @@ function readinessManagerFactory(EventEmitter, settings, splits) {
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
         init: function () {
-            if (readyTimeout > 0) {
-                readyTimeoutId = setTimeout(timeout, readyTimeout);
-            }
+            if (splits.initialized)
+                return;
+            splits.initialized = true;
+            splits.initCallbacks.forEach(function (cb) { return cb(); });
         },
         destroy: function () {
             isDestroyed = true;

package/cjs/sdkClient/sdkClientMethodCS.js

@@ -14,7 +14,7 @@ var identity_1 = require("./identity");
  * Therefore, clients don't have a bound TT for the track method.
  */
 function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log, whenInit = params.whenInit;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
     var mainClientInstance = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)(params), key);
     var parsedDefaultKey = (0, key_2.keyParser)(key);
     var defaultInstanceId = (0, identity_1.buildInstanceId)(parsedDefaultKey);
@@ -47,18 +47,14 @@ function sdkClientMethodCSFactory(params) {
             // - Consumer mode: both syncManager and sharedSyncManager are undefined
             // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
             // @ts-ignore
-            var sharedSyncManager_1 = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
+            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
             clients[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
-                syncManager: sharedSyncManager_1,
+                syncManager: sharedSyncManager,
             }), true), validKey);
-            whenInit(function () {
-                sharedSdkReadiness_1.readinessManager.init();
-                sharedSyncManager_1 && sharedSyncManager_1.start();
-            });
             log.info(constants_1.NEW_SHARED_CLIENT);
         }
         else {

package/cjs/sdkClient/sdkClientMethodCSWithTT.js

@@ -16,7 +16,7 @@ var identity_1 = require("./identity");
  * (default client) or the client method (shared clients).
  */
 function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log, whenInit = params.whenInit;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log;
     var mainClientInstance = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)(params), key, trafficType);
     var parsedDefaultKey = (0, key_2.keyParser)(key);
     var defaultInstanceId = (0, identity_1.buildInstanceId)(parsedDefaultKey, trafficType);
@@ -56,18 +56,14 @@ function sdkClientMethodCSFactory(params) {
             // - Consumer mode: both syncManager and sharedSyncManager are undefined
             // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
             // @ts-ignore
-            var sharedSyncManager_1 = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
+            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
             clients[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
-                syncManager: sharedSyncManager_1,
+                syncManager: sharedSyncManager,
             }), true), validKey, validTrafficType);
-            whenInit(function () {
-                sharedSdkReadiness_1.readinessManager.init();
-                sharedSyncManager_1 && sharedSyncManager_1.start();
-            });
             log.info(constants_1.NEW_SHARED_CLIENT);
         }
         else {

package/cjs/sdkFactory/index.js

@@ -19,15 +19,15 @@ 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, isPure = params.isPure;
+    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.
     // initialization
-    var isInit = false;
+    var hasInit = false;
     var initCallbacks = [];
     function whenInit(cb) {
-        if (isInit)
+        if (hasInit)
             cb();
         else
             initCallbacks.push(cb);
@@ -45,10 +45,8 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
             readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
         },
-        onReadyFromCacheCb: function () {
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
-        }
     });
+    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
@@ -69,7 +67,7 @@ function sdkFactory(params) {
     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, whenInit: whenInit };
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -78,21 +76,18 @@ function sdkFactory(params) {
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
     function init() {
-        if (isInit)
+        if (hasInit)
             return;
-        isInit = true;
+        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();
-        storage.init && storage.init();
         uniqueKeysTracker && uniqueKeysTracker.start();
         syncManager && syncManager.start();
         signalListener && signalListener.start();
         initCallbacks.forEach(function (cb) { return cb(); });
         initCallbacks.length = 0;
     }
-    if (!isPure)
-        init();
     log.info(constants_1.NEW_FACTORY);
     // @ts-ignore
     return (0, objectAssign_1.objectAssign)({
@@ -109,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), isPure && { init: init });
+    }, 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/AbstractSplitsCacheAsync.js

@@ -14,6 +14,13 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     AbstractSplitsCacheAsync.prototype.usesSegments = function () {
         return Promise.resolve(true);
     };
+    /**
+     * Check if the splits information is already stored in cache.
+     * Noop, just keeping the interface. This is used by client-side implementations only.
+     */
+    AbstractSplitsCacheAsync.prototype.checkCache = function () {
+        return Promise.resolve(false);
+    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -30,6 +30,13 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
         var _this = this;
         return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
     };
+    /**
+     * Check if the splits information is already stored in cache. This data can be preloaded.
+     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+     */
+    AbstractSplitsCacheSync.prototype.checkCache = function () {
+        return false;
+    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/cjs/storages/dataLoader.js

@@ -1,83 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSnapshot = exports.loadData = void 0;
-var sets_1 = require("../utils/lang/sets");
-var key_1 = require("../utils/key");
+exports.dataLoaderFactory = void 0;
+var browser_1 = require("../utils/constants/browser");
 /**
- * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
- * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+ * Factory of client-side storage loader
  *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
- * @param storage object containing `splits` and `segments` cache (client-side variant)
- * @param userKey user key (matching key) of the provided MySegmentsCache
- *
- * @TODO extend to load largeSegments
- * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
- * @TODO add logs, and input validation in this module, in favor of size reduction.
- * @TODO unit tests
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
+ * and extended with a `mySegmentsData` property.
+ * @returns function to preload the storage
  */
-function loadData(preloadedData, storage, matchingKey) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0)
-        return;
-    var _a = preloadedData.segmentsData, segmentsData = _a === void 0 ? {} : _a, _b = preloadedData.since, since = _b === void 0 ? -1 : _b, _c = preloadedData.splitsData, splitsData = _c === void 0 ? [] : _c;
-    if (storage.splits) {
+function dataLoaderFactory(preloadedData) {
+    /**
+     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+     *
+     * @param storage object containing `splits` and `segments` cache (client-side variant)
+     * @param userId user key string of the provided MySegmentsCache
+     *
+     * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
+     * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
+     */
+    return function loadData(storage, userId) {
+        // Do not load data if current preloadedData is empty
+        if (Object.keys(preloadedData).length === 0)
+            return;
+        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
         var storedSince = storage.splits.getChangeNumber();
-        // Do not load data if current data is more recent
-        if (storedSince > since)
+        var expirationTimestamp = Date.now() - browser_1.DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
+        // Do not load data if current localStorage data is more recent,
+        // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
+        if (storedSince > since || lastUpdated < expirationTimestamp)
             return;
         // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
         storage.splits.clear();
         storage.splits.setChangeNumber(since);
         // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
-    }
-    if (matchingKey) { // add mySegments data (client-side)
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[matchingKey];
+        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
+        // add mySegments data
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         if (!mySegmentsData) {
             // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
             mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var matchingKeys = segmentsData[segmentName];
-                return matchingKeys.indexOf(matchingKey) > -1;
+                var userIds = JSON.parse(segmentsData[segmentName]).added;
+                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
             });
         }
         storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
-    }
-    else { // add segments data (server-side)
-        Object.keys(segmentsData).filter(function (segmentName) {
-            var matchingKeys = segmentsData[segmentName];
-            storage.segments.addToSegment(segmentName, matchingKeys);
-        });
-    }
-}
-exports.loadData = loadData;
-function getSnapshot(storage, userKeys) {
-    return {
-        // lastUpdated: Date.now(),
-        since: storage.splits.getChangeNumber(),
-        splitsData: storage.splits.getAll(),
-        segmentsData: userKeys ?
-            undefined : // @ts-ignore accessing private prop
-            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
-                prev[cur] = (0, sets_1.setToArray)(storage.segments.segmentCache[cur]);
-                return prev;
-            }, {}),
-        mySegmentsData: userKeys ?
-            userKeys.reduce(function (prev, userKey) {
-                prev[(0, key_1.getMatching)(userKey)] = storage.shared ?
-                    // Client-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.shared(userKey).segments.segmentCache) :
-                    // Server-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
-                        return storage.segments.segmentCache[segmentName].has(userKey) ?
-                            prev.concat(segmentName) :
-                            prev;
-                    }, []);
-                return prev;
-            }, {}) :
-            undefined
     };
 }
-exports.getSnapshot = getSnapshot;
+exports.dataLoaderFactory = dataLoaderFactory;

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)
@@ -76,7 +76,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 + '');
@@ -97,5 +97,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

@@ -186,6 +186,14 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return true;
         }
     };
+    /**
+     * Check if the splits information is already stored in browser LocalStorage.
+     * In this function we could add more code to check if the data is valid.
+     * @override
+     */
+    SplitsCacheInLocal.prototype.checkCache = function () {
+        return this.getChangeNumber() > -1;
+    };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *
@@ -208,7 +216,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;
                 // if there is cache, clear it
-                if (this.getChangeNumber() > -1)
+                if (this.checkCache())
                     this.clear();
             }
             catch (e) {

package/cjs/storages/inLocalStorage/index.js

@@ -30,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 onReadyFromCacheCb = params.onReadyFromCacheCb, 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 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;
@@ -46,11 +46,6 @@ 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,
-            init: function () {
-                if (settings.mode === constants_2.LOCALHOST_MODE || splits.getChangeNumber() > -1) {
-                    Promise.resolve().then(onReadyFromCacheCb);
-                }
-            },
             destroy: function () {
                 var _a;
                 this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -9,15 +9,13 @@ var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory")
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
-var key_1 = require("../../utils/key");
-var dataLoader_1 = require("../dataLoader");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
@@ -41,16 +39,11 @@ function InMemoryStorageCSFactory(params) {
             this.uniqueKeys && this.uniqueKeys.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function (matchingKey) {
-            var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-            var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-            if (preloadedData) {
-                (0, dataLoader_1.loadData)(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
-            }
+        shared: function () {
             return {
                 splits: this.splits,
-                segments: segments,
-                largeSegments: largeSegments,
+                segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -65,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;
@@ -75,11 +68,6 @@ function InMemoryStorageCSFactory(params) {
         if (storage.uniqueKeys)
             storage.uniqueKeys.track = noopTrack;
     }
-    if (preloadedData) {
-        (0, dataLoader_1.loadData)(preloadedData, storage, (0, key_1.getMatching)(params.settings.core.key));
-        if (splits.getChangeNumber() > -1)
-            onReadyFromCacheCb();
-    }
     return storage;
 }
 exports.InMemoryStorageCSFactory = InMemoryStorageCSFactory;

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;