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

package/cjs/utils/settingsValidation/index.js

@@ -186,11 +186,10 @@ function settingsValidation(config, validationParams) {
     var splitFiltersValidation = (0, splitFilters_1.validateSplitFilters)(log, sync.splitFilters, withDefaults.mode);
     sync.splitFilters = splitFiltersValidation.validFilters;
     sync.__splitFiltersValidation = splitFiltersValidation;
-    // ensure a valid flag spec version
     sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : constants_1.FLAG_SPEC_VERSION;
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
-    withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
+    withDefaults.userConsent = consent(withDefaults);
     return withDefaults;
 }
 exports.settingsValidation = settingsValidation;

package/esm/consent/sdkUserConsent.js

@@ -12,7 +12,7 @@ var ConsentStatus = {
  * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
  */
 export function createUserConsentAPI(params) {
-    var settings = params.settings, log = params.settings.log, syncManager = params.syncManager, _a = params.storage, events = _a.events, impressions = _a.impressions, impressionCounts = _a.impressionCounts;
+    var settings = params.settings, log = params.settings.log, syncManager = params.syncManager, _a = params.storage, events = _a.events, impressions = _a.impressions, impressionCounts = _a.impressionCounts, uniqueKeys = _a.uniqueKeys;
     if (!isConsentGranted(settings))
         log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
     return {
@@ -38,7 +38,9 @@ export function createUserConsentAPI(params) {
                     if (impressions.clear)
                         impressions.clear(); // @ts-ignore
                     if (impressionCounts && impressionCounts.clear)
-                        impressionCounts.clear();
+                        impressionCounts.clear(); // @ts-ignore
+                    if (uniqueKeys && uniqueKeys.clear)
+                        uniqueKeys.clear();
                 }
             }
             else {

package/esm/evaluator/matchers/index.js

@@ -1,6 +1,5 @@
 import { allMatcherContext } from './all';
 import { segmentMatcherContext } from './segment';
-import { largeSegmentMatcherContext } from './large_segment';
 import { whitelistMatcherContext } from './whitelist';
 import { equalToMatcherContext } from './eq';
 import { greaterThanEqualMatcherContext } from './gte';
@@ -44,8 +43,7 @@ var matchers = [
     greaterThanEqualToSemverMatcherContext,
     lessThanEqualToSemverMatcherContext,
     betweenSemverMatcherContext,
-    inListSemverMatcherContext,
-    largeSegmentMatcherContext, // IN_LARGE_SEGMENT: 23
+    inListSemverMatcherContext, // IN_LIST_SEMVER: 22
 ];
 /**
  * Matcher factory.

package/esm/evaluator/matchers/matcherTypes.js

@@ -22,7 +22,6 @@ export var matcherTypes = {
     LESS_THAN_OR_EQUAL_TO_SEMVER: 20,
     BETWEEN_SEMVER: 21,
     IN_LIST_SEMVER: 22,
-    IN_LARGE_SEGMENT: 23,
 };
 export var matcherDataTypes = {
     BOOLEAN: 'BOOLEAN',

package/esm/evaluator/matchers/segment.js

@@ -1,12 +1,6 @@
-import { thenable } from '../../utils/promise/thenable';
 export function segmentMatcherContext(segmentName, storage) {
     return function segmentMatcher(key) {
         var isInSegment = storage.segments.isInSegment(segmentName, key);
-        if (thenable(isInSegment)) {
-            isInSegment.then(function (result) {
-                return result;
-            });
-        }
         return isInSegment;
     };
 }

package/esm/evaluator/matchersTransform/index.js

@@ -9,7 +9,7 @@ import { zeroSinceHH, zeroSinceSS } from '../convertions';
  */
 export function matchersTransform(matchers) {
     var parsedMatchers = matchers.map(function (matcher) {
-        var matcherType = matcher.matcherType, negate = matcher.negate, keySelector = matcher.keySelector, userDefinedSegmentMatcherData = matcher.userDefinedSegmentMatcherData, userDefinedLargeSegmentMatcherData = matcher.userDefinedLargeSegmentMatcherData, whitelistMatcherData = matcher.whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */ unaryNumericMatcherData = matcher.unaryNumericMatcherData, betweenMatcherData = matcher.betweenMatcherData, dependencyMatcherData = matcher.dependencyMatcherData, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData, betweenStringMatcherData = matcher.betweenStringMatcherData;
+        var matcherType = matcher.matcherType, negate = matcher.negate, keySelector = matcher.keySelector, userDefinedSegmentMatcherData = matcher.userDefinedSegmentMatcherData, whitelistMatcherData = matcher.whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */ unaryNumericMatcherData = matcher.unaryNumericMatcherData, betweenMatcherData = matcher.betweenMatcherData, dependencyMatcherData = matcher.dependencyMatcherData, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData, betweenStringMatcherData = matcher.betweenStringMatcherData;
         var attribute = keySelector && keySelector.attribute;
         var type = matcherTypesMapper(matcherType);
         // As default input data type we use string (even for ALL_KEYS)
@@ -18,9 +18,6 @@ export function matchersTransform(matchers) {
         if (type === matcherTypes.IN_SEGMENT) {
             value = segmentTransform(userDefinedSegmentMatcherData);
         }
-        else if (type === matcherTypes.IN_LARGE_SEGMENT) {
-            value = segmentTransform(userDefinedLargeSegmentMatcherData);
-        }
         else if (type === matcherTypes.EQUAL_TO) {
             value = numericTransform(unaryNumericMatcherData);
             dataType = matcherDataTypes.NUMBER;

package/esm/evaluator/matchersTransform/segment.js

@@ -2,7 +2,5 @@
  * Extract segment name as a plain string.
  */
 export function segmentTransform(segment) {
-    return segment ?
-        segment.segmentName || segment.largeSegmentName :
-        undefined;
+    return segment ? segment.segmentName : undefined;
 }

package/esm/logger/constants.js

@@ -77,7 +77,7 @@ export var WARN_SPLITS_FILTER_IGNORED = 219;
 export var WARN_SPLITS_FILTER_INVALID = 220;
 export var WARN_SPLITS_FILTER_EMPTY = 221;
 export var WARN_SDK_KEY = 222;
-export var STREAMING_PARSING_MEMBERSHIPS_UPDATE = 223;
+export var STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export var STREAMING_PARSING_SPLIT_UPDATE = 224;
 export var WARN_INVALID_FLAGSET = 225;
 export var WARN_LOWERCASE_FLAGSET = 226;

package/esm/logger/messages/info.js

@@ -20,7 +20,7 @@ export var codesInfo = codesWarn.concat([
     [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
     [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
     [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
+    [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
     [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/esm/logger/messages/warn.js

@@ -30,7 +30,7 @@ export var codesWarn = codesError.concat([
     [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS + ': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("bySet", "byName" or "byPrefix") and a list of "values".'],
     [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': feature flag filter configuration must be a non-empty array of filter objects.'],
     [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
-    [c.STREAMING_PARSING_MEMBERSHIPS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
+    [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
     [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
     [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
     [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],

package/esm/readiness/readinessManager.js

@@ -4,11 +4,9 @@ function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = objectAssign(new EventEmitter(), {
         splitsArrived: false,
         splitsCacheLoaded: false,
-        initialized: false,
-        initCallbacks: []
     });
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
-    // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+    // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
     // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
     splitsEventEmitter.on(SDK_SPLITS_ARRIVED, function (isSplitKill) { if (!isSplitKill)
         splitsEventEmitter.splitsArrived = true; });
@@ -25,9 +23,9 @@ function segmentsEventEmitterFactory(EventEmitter) {
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export function readinessManagerFactory(EventEmitter, settings, splits) {
+export function readinessManagerFactory(EventEmitter, readyTimeout, splits) {
+    if (readyTimeout === void 0) { readyTimeout = 0; }
     if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
-    var readyTimeout = settings.startup.readyTimeout;
     var segments = segmentsEventEmitterFactory(EventEmitter);
     var gate = new EventEmitter();
     var lastUpdate = 0;
@@ -45,7 +43,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
-        if (hasTimedout || isReady)
+        if (hasTimedout)
             return;
         hasTimedout = true;
         syncLastUpdate();
@@ -53,10 +51,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     }
     var readyTimeoutId;
     if (readyTimeout > 0) {
-        if (splits.initialized)
-            readyTimeoutId = setTimeout(timeout, readyTimeout);
-        else
-            splits.initCallbacks.push(function () { readyTimeoutId = setTimeout(timeout, readyTimeout); });
+        readyTimeoutId = setTimeout(timeout, readyTimeout);
     }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
@@ -108,9 +103,10 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
         splits: splits,
         segments: segments,
         gate: gate,
-        shared: function () {
+        shared: function (readyTimeout) {
+            if (readyTimeout === void 0) { readyTimeout = 0; }
             refCount++;
-            return readinessManagerFactory(EventEmitter, settings, splits);
+            return readinessManagerFactory(EventEmitter, readyTimeout, splits);
         },
         // @TODO review/remove next methods when non-recoverable errors are reworked
         // Called on consumer mode, when storage fails to connect
@@ -118,12 +114,6 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
         // Called on 403 error (client-side SDK key on server-side), to set the SDK as destroyed for
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
-        init: function () {
-            if (splits.initialized)
-                return;
-            splits.initialized = true;
-            splits.initCallbacks.forEach(function (cb) { return cb(); });
-        },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();

package/esm/readiness/sdkReadinessManager.js

@@ -12,9 +12,9 @@ var REMOVE_LISTENER_EVENT = 'removeListener';
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
-    if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, settings); }
-    var log = settings.log;
+export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager) {
+    if (readyTimeout === void 0) { readyTimeout = 0; }
+    if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, readyTimeout); }
     /** Ready callback warning */
     var internalReadyCbCount = 0;
     var readyCbCount = 0;
@@ -57,8 +57,9 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
     }
     return {
         readinessManager: readinessManager,
-        shared: function () {
-            return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
+        shared: function (readyTimeout) {
+            if (readyTimeout === void 0) { readyTimeout = 0; }
+            return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
         },
         incInternalReadyCbCount: function () {
             internalReadyCbCount++;

package/esm/sdkClient/sdkClient.js

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

package/esm/sdkClient/sdkClientMethod.js

@@ -1,13 +1,11 @@
 import { sdkClientFactory } from './sdkClient';
 import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 /**
- * Factory of client method for server-side SDKs
+ * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
 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,18 +5,22 @@ 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';
-import { buildInstanceId } from './identity';
+function buildInstanceId(key) {
+    // @ts-ignore
+    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-";
+}
 /**
  * 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 clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
+    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, readyTimeout = _a.startup.readyTimeout, log = _a.log;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
     // Cache instances created per factory.
-    clients[defaultInstanceId] = mainClientInstance;
+    var clientInstances = {};
+    clientInstances[defaultInstanceId] = mainClientInstance;
     return function client(key) {
         if (key === undefined) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
@@ -28,9 +32,9 @@ export function sdkClientMethodCSFactory(params) {
             throw new Error('Shared Client needs a valid key.');
         }
         var instanceId = buildInstanceId(validKey);
-        if (!clients[instanceId]) {
+        if (!clientInstances[instanceId]) {
             var matchingKey = getMatching(validKey);
-            var sharedSdkReadiness_1 = sdkReadinessManager.shared();
+            var sharedSdkReadiness_1 = sdkReadinessManager.shared(readyTimeout);
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
                 if (err) {
                     sharedSdkReadiness_1.readinessManager.timeout();
@@ -47,16 +51,18 @@ 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.
-            clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
+            clientInstances[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);
         }
         else {
             log.debug(RETRIEVE_CLIENT_EXISTING);
         }
-        return clients[instanceId];
+        return clientInstances[instanceId];
     };
 }

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -6,19 +6,23 @@ 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';
-import { buildInstanceId } from './identity';
+function buildInstanceId(key, trafficType) {
+    // @ts-ignore
+    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType !== undefined ? trafficType : '');
+}
 /**
  * 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).
  */
 export 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;
+    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, readyTimeout = _a.startup.readyTimeout, log = _a.log;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key, trafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
     // Cache instances created per factory.
-    clients[defaultInstanceId] = mainClientInstance;
+    var clientInstances = {};
+    clientInstances[defaultInstanceId] = mainClientInstance;
     return function client(key, trafficType) {
         if (key === undefined) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
@@ -37,9 +41,9 @@ export function sdkClientMethodCSFactory(params) {
             }
         }
         var instanceId = buildInstanceId(validKey, validTrafficType);
-        if (!clients[instanceId]) {
+        if (!clientInstances[instanceId]) {
             var matchingKey = getMatching(validKey);
-            var sharedSdkReadiness_1 = sdkReadinessManager.shared();
+            var sharedSdkReadiness_1 = sdkReadinessManager.shared(readyTimeout);
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
                 if (err) {
                     sharedSdkReadiness_1.readinessManager.timeout();
@@ -56,16 +60,18 @@ 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.
-            clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
+            clientInstances[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, validTrafficType);
+            sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
         }
         else {
             log.debug(RETRIEVE_CLIENT_EXISTING);
         }
-        return clients[instanceId];
+        return clientInstances[instanceId];
     };
 }

package/esm/sdkFactory/index.js

@@ -16,20 +16,13 @@ import { NONE, OPTIMIZED } from '../utils/constants';
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
     var 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 hasInit = false;
-    var initCallbacks = [];
-    function whenInit(cb) {
-        if (hasInit)
-            cb();
-        else
-            initCallbacks.push(cb);
-    }
-    var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
+    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+    validateAndTrackApiKey(log, settings.core.authorizationKey);
+    var sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
         settings: settings,
@@ -44,7 +37,6 @@ export function sdkFactory(params) {
         },
     });
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-    var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
@@ -60,11 +52,11 @@ export function sdkFactory(params) {
         default:
             strategy = strategyDebugFactory(observer);
     }
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+    var eventTracker = 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 = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { 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);
@@ -72,19 +64,8 @@ export function sdkFactory(params) {
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    function init() {
-        if (hasInit)
-            return;
-        hasInit = true;
-        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-        validateAndTrackApiKey(log, settings.core.authorizationKey);
-        readiness.init();
-        uniqueKeysTracker && uniqueKeysTracker.start();
-        syncManager && syncManager.start();
-        signalListener && signalListener.start();
-        initCallbacks.forEach(function (cb) { return cb(); });
-        initCallbacks.length = 0;
-    }
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
     log.info(NEW_FACTORY);
     // @ts-ignore
     return objectAssign({
@@ -98,8 +79,5 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(log),
         settings: settings,
-        destroy: function () {
-            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
-        }
-    }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());
+    }, extraProps && extraProps(ctx));
 }

package/esm/services/decorateHeaders.js

@@ -30,3 +30,7 @@ export function decorateHeaders(settings, headers) {
     }
     return headers;
 }
+export function removeNonISO88591(input) {
+    // eslint-disable-next-line no-control-regex
+    return input.replace(/[^\x00-\xFF]/g, '');
+}

package/esm/services/splitApi.js

@@ -1,6 +1,6 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
@@ -51,15 +51,15 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
         },
-        fetchMemberships: function (userMatchingKey, noCache, till) {
+        fetchMySegments: function (userMatchingKey, noCache) {
             /**
              * URI encoding of user keys in order to:
-             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-             *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
+             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
+             *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
-            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
+            var url = urls.sdk + "/mySegments/" + encodeURIComponent(userMatchingKey);
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
         },
         /**
          * Post events.

package/esm/services/splitHttpClient.js

@@ -1,6 +1,8 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
-import { decorateHeaders } from './decorateHeaders';
+import { decorateHeaders, removeNonISO88591 } from './decorateHeaders';
+import { timeout } from '../utils/promise/timeout';
+var PENDING_FETCH_ERROR_TIMEOUT = 100;
 var messageNoFetch = 'Global fetch API is not available.';
 /**
  * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.
@@ -25,7 +27,7 @@ export function splitHttpClientFactory(settings, _a) {
     if (ip)
         commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
-        commonHeaders['SplitSDKMachineName'] = hostname;
+        commonHeaders['SplitSDKMachineName'] = removeNonISO88591(hostname);
     return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
@@ -40,7 +42,8 @@ export function splitHttpClientFactory(settings, _a) {
             // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
             .then(function (response) {
             if (!response.ok) {
-                return response.text().then(function (message) { return Promise.reject({ response: response, message: message }); });
+                // `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
+                return timeout(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(function (message) { return Promise.reject({ response: response, message: message }); }, function () { return Promise.reject({ response: response }); });
             }
             latencyTracker();
             return response;

package/esm/storages/AbstractSegmentsCacheSync.js

@@ -0,0 +1,30 @@
+/**
+ * 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() {
+    }
+    /**
+     * 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; };
+    /**
+     * For server-side synchronizer: set the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    AbstractSegmentsCacheSync.prototype.setChangeNumber = function (name, changeNumber) { return true; };
+    /**
+     * For server-side synchronizer: get the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    AbstractSegmentsCacheSync.prototype.getChangeNumber = function (name) { return -1; };
+    /**
+     * For server-side synchronizer: the method is not used.
+     * For client-side synchronizer: reset the cache with the given list of segments.
+     */
+    AbstractSegmentsCacheSync.prototype.resetSegments = function (names) { return true; };
+    return AbstractSegmentsCacheSync;
+}());
+export { AbstractSegmentsCacheSync };

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
+import { IN_SEGMENT } from '../utils/constants';
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
@@ -67,8 +67,7 @@ export function usesSegments(split) {
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
+            if (matchers[j].matcherType === IN_SEGMENT)
                 return true;
         }
     }

package/esm/storages/KeyBuilderCS.js

@@ -21,6 +21,10 @@ var KeyBuilderCS = /** @class */ (function (_super) {
             return builtSegmentKeyName.substr(prefix.length);
     };
     // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+    KeyBuilderCS.prototype.buildOldSegmentNameKey = function (segmentName) {
+        return this.matchingKey + "." + this.prefix + ".segment." + segmentName;
+    };
+    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
     KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {
         var prefix = this.matchingKey + "." + this.prefix + ".segment.";
         if (startsWith(builtSegmentKeyName, prefix))
@@ -32,27 +36,6 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
         return this.regexSplitsCacheKey.test(key);
     };
-    KeyBuilderCS.prototype.buildTillKey = function () {
-        return this.prefix + "." + this.matchingKey + ".segments.till";
-    };
     return KeyBuilderCS;
 }(KeyBuilder));
 export { KeyBuilderCS };
-export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
-    return {
-        buildSegmentNameKey: function (segmentName) {
-            return prefix + "." + matchingKey + ".largeSegment." + segmentName;
-        },
-        extractSegmentName: function (builtSegmentKeyName) {
-            var p = prefix + "." + matchingKey + ".largeSegment.";
-            if (startsWith(builtSegmentKeyName, p))
-                return builtSegmentKeyName.substr(p.length);
-        },
-        extractOldSegmentKey: function () {
-            return undefined;
-        },
-        buildTillKey: function () {
-            return prefix + "." + matchingKey + ".largeSegments.till";
-        }
-    };
-}