@splitsoftware/splitio-commons 1.17.1-rc.0 → 1.17.1-rc.2

package/CHANGES.txt

@@ -1,6 +1,9 @@
 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.
  - Added support for targeting rules based on large segments.
  - BREAKING CHANGES:
+   - Updated default flag spec version to 1.2.
    - Removed `/mySegments` endpoint from SplitAPI module, as it is replaced by `/memberships` endpoint.
    - Removed support for MY_SEGMENTS_UPDATE and MY_SEGMENTS_UPDATE_V2 notification types, as they are replaced by MEMBERSHIPS_MS_UPDATE and MEMBERSHIPS_LS_UPDATE notification types.
 

package/cjs/sdkClient/identity.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInstanceId = void 0;
+function buildInstanceId(key, trafficType) {
+    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType ? trafficType : '');
+}
+exports.buildInstanceId = buildInstanceId;

package/cjs/sdkClient/sdkClient.js

@@ -53,11 +53,11 @@ function sdkClientFactory(params, isSharedClient) {
             // Stop background jobs
             syncManager && syncManager.stop();
             return __flush().then(function () {
-                // Cleanup event listeners
-                signalListener && signalListener.stop();
-                // @TODO stop only if last client is destroyed
-                if (uniqueKeysTracker)
-                    uniqueKeysTracker.stop();
+                // For main client, cleanup event listeners and scheduled jobs
+                if (!isSharedClient) {
+                    signalListener && signalListener.stop();
+                    uniqueKeysTracker && uniqueKeysTracker.stop();
+                }
                 // Cleanup storage
                 return storage.destroy();
             });

package/cjs/sdkClient/sdkClientMethod.js

@@ -4,11 +4,13 @@ exports.sdkClientMethodFactory = void 0;
 var sdkClient_1 = require("./sdkClient");
 var constants_1 = require("../logger/constants");
 /**
- * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
+ * Factory of client method for server-side SDKs
  */
 function sdkClientMethodFactory(params) {
     var log = params.settings.log;
     var clientInstance = (0, sdkClient_1.sdkClientFactory)(params);
+    // Only one client in server-side without bound key
+    params.clients[''] = clientInstance;
     return function client() {
         if (arguments.length > 0) {
             throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');

package/cjs/sdkClient/sdkClientMethodCS.js

@@ -8,22 +8,18 @@ var sdkClient_1 = require("./sdkClient");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../logger/constants");
 var constants_2 = require("../readiness/constants");
-function buildInstanceId(key) {
-    // @ts-ignore
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-";
-}
+var identity_1 = require("./identity");
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
  */
 function sdkClientMethodCSFactory(params) {
-    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
+    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 = buildInstanceId(parsedDefaultKey);
+    var defaultInstanceId = (0, identity_1.buildInstanceId)(parsedDefaultKey);
     // Cache instances created per factory.
-    var clientInstances = {};
-    clientInstances[defaultInstanceId] = mainClientInstance;
+    clients[defaultInstanceId] = mainClientInstance;
     return function client(key) {
         if (key === undefined) {
             log.debug(constants_1.RETRIEVE_CLIENT_DEFAULT);
@@ -34,8 +30,8 @@ function sdkClientMethodCSFactory(params) {
         if (validKey === false) {
             throw new Error('Shared Client needs a valid key.');
         }
-        var instanceId = buildInstanceId(validKey);
-        if (!clientInstances[instanceId]) {
+        var instanceId = (0, identity_1.buildInstanceId)(validKey);
+        if (!clients[instanceId]) {
             var matchingKey = (0, key_2.getMatching)(validKey);
             var sharedSdkReadiness_1 = sdkReadinessManager.shared();
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
@@ -54,11 +50,10 @@ function sdkClientMethodCSFactory(params) {
             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.
-            clientInstances[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
+            clients[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined, // only the main client "destroy" method stops the signal listener
             }), true), validKey);
             sharedSyncManager && sharedSyncManager.start();
             log.info(constants_1.NEW_SHARED_CLIENT);
@@ -66,7 +61,7 @@ function sdkClientMethodCSFactory(params) {
         else {
             log.debug(constants_1.RETRIEVE_CLIENT_EXISTING);
         }
-        return clientInstances[instanceId];
+        return clients[instanceId];
     };
 }
 exports.sdkClientMethodCSFactory = sdkClientMethodCSFactory;

package/cjs/sdkClient/sdkClientMethodCSWithTT.js

@@ -9,23 +9,19 @@ var sdkClient_1 = require("./sdkClient");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../logger/constants");
 var constants_2 = require("../readiness/constants");
-function buildInstanceId(key, trafficType) {
-    // @ts-ignore
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType !== undefined ? trafficType : '');
-}
+var identity_1 = require("./identity");
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
  * where clients can have a bound TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
 function sdkClientMethodCSFactory(params) {
-    var 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 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 = buildInstanceId(parsedDefaultKey, trafficType);
+    var defaultInstanceId = (0, identity_1.buildInstanceId)(parsedDefaultKey, trafficType);
     // Cache instances created per factory.
-    var clientInstances = {};
-    clientInstances[defaultInstanceId] = mainClientInstance;
+    clients[defaultInstanceId] = mainClientInstance;
     return function client(key, trafficType) {
         if (key === undefined) {
             log.debug(constants_1.RETRIEVE_CLIENT_DEFAULT);
@@ -43,8 +39,8 @@ function sdkClientMethodCSFactory(params) {
                 throw new Error('Shared Client needs a valid traffic type or no traffic type at all.');
             }
         }
-        var instanceId = buildInstanceId(validKey, validTrafficType);
-        if (!clientInstances[instanceId]) {
+        var instanceId = (0, identity_1.buildInstanceId)(validKey, validTrafficType);
+        if (!clients[instanceId]) {
             var matchingKey = (0, key_2.getMatching)(validKey);
             var sharedSdkReadiness_1 = sdkReadinessManager.shared();
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
@@ -63,11 +59,10 @@ function sdkClientMethodCSFactory(params) {
             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.
-            clientInstances[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
+            clients[instanceId] = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)((0, objectAssign_1.objectAssign)({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined, // only the main client "destroy" method stops the signal listener
             }), true), validKey, validTrafficType);
             sharedSyncManager && sharedSyncManager.start();
             log.info(constants_1.NEW_SHARED_CLIENT);
@@ -75,7 +70,7 @@ function sdkClientMethodCSFactory(params) {
         else {
             log.debug(constants_1.RETRIEVE_CLIENT_EXISTING);
         }
-        return clientInstances[instanceId];
+        return clients[instanceId];
     };
 }
 exports.sdkClientMethodCSFactory = sdkClientMethodCSFactory;

package/cjs/sdkFactory/index.js

@@ -38,8 +38,11 @@ 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 });
     var observer = impressionsObserverFactory();
@@ -59,7 +62,7 @@ function sdkFactory(params) {
     var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    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);
@@ -82,6 +85,9 @@ function sdkFactory(params) {
         // Logger wrapper API
         Logger: (0, sdkLogger_1.createLoggerAPI)(log),
         settings: settings,
+        destroy: function () {
+            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
+        }
     }, extraProps && extraProps(ctx));
 }
 exports.sdkFactory = sdkFactory;

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -14,13 +14,6 @@ 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,13 +30,6 @@ 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,51 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataLoaderFactory = void 0;
-var browser_1 = require("../utils/constants/browser");
+exports.getSnapshot = exports.loadData = void 0;
+var sets_1 = require("../utils/lang/sets");
 /**
- * Factory of client-side storage loader
+ * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+ * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
  *
- * @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
+ * @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
  */
-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;
+function loadData(preloadedData, storage, userKey) {
+    // 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) {
         var storedSince = storage.splits.getChangeNumber();
-        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)
+        // Do not load data if current data is more recent
+        if (storedSince > since)
             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(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
+        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
+    }
+    if (userKey) { // add mySegments data (client-side)
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
         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 userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+                var userKeys = segmentsData[segmentName];
+                return userKeys.indexOf(userKey) > -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 userKeys = segmentsData[segmentName];
+            storage.segments.addToSegment(segmentName, userKeys);
+        });
+    }
+}
+exports.loadData = loadData;
+function getSnapshot(storage, userKeys) {
+    return {
+        // lastUpdated: Date.now(),
+        // @ts-ignore accessing private prop
+        since: storage.splits.changeNumber,
+        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) {
+                // @ts-ignore accessing private prop
+                prev[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.dataLoaderFactory = dataLoaderFactory;
+exports.getSnapshot = getSnapshot;

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -186,14 +186,6 @@ 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`,
      *
@@ -216,7 +208,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.checkCache())
+                if (this.getChangeNumber() > -1)
                     this.clear();
             }
             catch (e) {

package/cjs/storages/inLocalStorage/index.js

@@ -30,13 +30,16 @@ 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, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+        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 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;
         var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
         var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey));
+        if (settings.mode === constants_2.LOCALHOST_MODE || splits.getChangeNumber() > -1) {
+            Promise.resolve().then(onReadyFromCacheCb);
+        }
         return {
             splits: splits,
             segments: segments,

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -9,13 +9,15 @@ 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;
+    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 splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
@@ -39,11 +41,16 @@ 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 () {
+        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);
+            }
             return {
                 splits: this.splits,
-                segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
+                segments: segments,
+                largeSegments: largeSegments,
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -68,6 +75,11 @@ 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/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -46,13 +46,8 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (cacheReady)
-                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
-                        // Emits SDK_READY
-                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
-                    });
+                    // Emits SDK_READY
+                    readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
                 }
                 return true;
             });

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

@@ -126,7 +126,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(constants_2.SYNC_SPLITS_FETCH, [since]);
-            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
+            return Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -170,15 +170,6 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
                 }
                 return false;
             });
-            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
-            // Wrapping in a promise since checkCache can be async.
-            if (splitsEventEmitter && startingUp) {
-                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {
-                    if (isCacheReady)
-                        splitsEventEmitter.emit(constants_1.SDK_SPLITS_CACHE_LOADED);
-                });
-            }
-            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -1,16 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateStorageCS = exports.__InLocalStorageMockFactory = void 0;
+exports.validateStorageCS = void 0;
 var InMemoryStorageCS_1 = require("../../../storages/inMemory/InMemoryStorageCS");
 var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
-function __InLocalStorageMockFactory(params) {
-    var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
-    return result;
-}
-exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;
-__InLocalStorageMockFactory.type = constants_2.STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -27,10 +20,6 @@ function validateStorageCS(settings) {
         storage = InMemoryStorageCS_1.InMemoryStorageCSFactory;
         log.error(constants_1.ERROR_STORAGE_INVALID);
     }
-    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
-    if (mode === constants_2.LOCALHOST_MODE && storage.type === constants_2.STORAGE_LOCALSTORAGE) {
-        return __InLocalStorageMockFactory;
-    }
     if ([constants_2.LOCALHOST_MODE, constants_2.STANDALONE_MODE].indexOf(mode) === -1) {
         // Consumer modes require an async storage
         if (storage.type !== constants_2.STORAGE_PLUGGABLE)

package/esm/sdkClient/identity.js

@@ -0,0 +1,3 @@
+export function buildInstanceId(key, trafficType) {
+    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType ? trafficType : '');
+}

package/esm/sdkClient/sdkClient.js

@@ -50,11 +50,11 @@ export function sdkClientFactory(params, isSharedClient) {
             // Stop background jobs
             syncManager && syncManager.stop();
             return __flush().then(function () {
-                // Cleanup event listeners
-                signalListener && signalListener.stop();
-                // @TODO stop only if last client is destroyed
-                if (uniqueKeysTracker)
-                    uniqueKeysTracker.stop();
+                // For main client, cleanup event listeners and scheduled jobs
+                if (!isSharedClient) {
+                    signalListener && signalListener.stop();
+                    uniqueKeysTracker && uniqueKeysTracker.stop();
+                }
                 // Cleanup storage
                 return storage.destroy();
             });

package/esm/sdkClient/sdkClientMethod.js

@@ -1,11 +1,13 @@
 import { sdkClientFactory } from './sdkClient';
 import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 /**
- * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
+ * Factory of client method for server-side SDKs
  */
 export function sdkClientMethodFactory(params) {
     var log = params.settings.log;
     var clientInstance = sdkClientFactory(params);
+    // Only one client in server-side without bound key
+    params.clients[''] = clientInstance;
     return function client() {
         if (arguments.length > 0) {
             throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');

package/esm/sdkClient/sdkClientMethodCS.js

@@ -5,22 +5,18 @@ import { sdkClientFactory } from './sdkClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
-function buildInstanceId(key) {
-    // @ts-ignore
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-";
-}
+import { buildInstanceId } from './identity';
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params) {
-    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
+    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 = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
     // Cache instances created per factory.
-    var clientInstances = {};
-    clientInstances[defaultInstanceId] = mainClientInstance;
+    clients[defaultInstanceId] = mainClientInstance;
     return function client(key) {
         if (key === undefined) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
@@ -32,7 +28,7 @@ export function sdkClientMethodCSFactory(params) {
             throw new Error('Shared Client needs a valid key.');
         }
         var instanceId = buildInstanceId(validKey);
-        if (!clientInstances[instanceId]) {
+        if (!clients[instanceId]) {
             var matchingKey = getMatching(validKey);
             var sharedSdkReadiness_1 = sdkReadinessManager.shared();
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
@@ -51,11 +47,10 @@ export function sdkClientMethodCSFactory(params) {
             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.
-            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
+            clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined, // only the main client "destroy" method stops the signal listener
             }), true), validKey);
             sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
@@ -63,6 +58,6 @@ export function sdkClientMethodCSFactory(params) {
         else {
             log.debug(RETRIEVE_CLIENT_EXISTING);
         }
-        return clientInstances[instanceId];
+        return clients[instanceId];
     };
 }