@splitsoftware/splitio-commons 3.1.1-rc.10 → 3.1.1-rc.11

package/esm/readiness/readinessManager.js

@@ -1,19 +1,19 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
-function splitsEventEmitterFactory(EventEmitter) {
-    var splitsEventEmitter = objectAssign(new EventEmitter(), {
-        splitsArrived: false,
-        splitsCacheLoaded: false,
+import { SDK_DEFINITIONS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
+function definitionsEventEmitterFactory(EventEmitter) {
+    var definitionsEventEmitter = objectAssign(new EventEmitter(), {
+        definitionsArrived: false,
+        definitionsCacheLoaded: false,
         hasInit: false,
         initCallbacks: []
     });
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
     // - `/memberships` 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 (metadata, isSplitKill) { if (!isSplitKill)
-        splitsEventEmitter.splitsArrived = true; });
-    splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
-    return splitsEventEmitter;
+    definitionsEventEmitter.on(SDK_DEFINITIONS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
+        definitionsEventEmitter.definitionsArrived = true; });
+    definitionsEventEmitter.once(SDK_DEFINITIONS_CACHE_LOADED, function () { definitionsEventEmitter.definitionsCacheLoaded = true; });
+    return definitionsEventEmitter;
 }
 function segmentsEventEmitterFactory(EventEmitter) {
     var segmentsEventEmitter = objectAssign(new EventEmitter(), {
@@ -25,8 +25,8 @@ function segmentsEventEmitterFactory(EventEmitter) {
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
-    if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
+export function readinessManagerFactory(EventEmitter, settings, definitions, isShared) {
+    if (definitions === void 0) { definitions = definitionsEventEmitterFactory(EventEmitter); }
     var readyTimeout = settings.startup.readyTimeout;
     var segments = segmentsEventEmitterFactory(EventEmitter);
     var gate = new EventEmitter();
@@ -41,10 +41,10 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
     };
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
-    if (splits.splitsCacheLoaded)
+    if (definitions.definitionsCacheLoaded)
         isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
     else
-        splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
+        definitions.once(SDK_DEFINITIONS_CACHE_LOADED, checkIsReadyFromCache);
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
@@ -52,11 +52,11 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
             return;
         hasTimedout = true;
         syncLastUpdate();
-        gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
+        gate.emit(SDK_READY_TIMED_OUT, 'SDK client emitted SDK_READY_TIMED_OUT event.');
     }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
-    splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
+    definitions.on(SDK_DEFINITIONS_ARRIVED, checkIsReadyOrUpdate);
     segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
     var isDestroyed = false;
     var readyTimeoutId;
@@ -65,8 +65,8 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         if (readyTimeout > 0 && !isReady)
             readyTimeoutId = setTimeout(timeout, readyTimeout);
     }
-    splits.initCallbacks.push(__init);
-    if (splits.hasInit)
+    definitions.initCallbacks.push(__init);
+    if (definitions.hasInit)
         __init();
     function checkIsReadyFromCache(cacheMetadata) {
         metadataReady = cacheMetadata;
@@ -97,7 +97,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
             }
         }
         else {
-            if (splits.splitsArrived && segments.segmentsArrived) {
+            if (definitions.definitionsArrived && segments.segmentsArrived) {
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
@@ -120,11 +120,11 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         }
     }
     return {
-        splits: splits,
+        definitions: definitions,
         segments: segments,
         gate: gate,
         shared: function () {
-            return readinessManagerFactory(EventEmitter, settings, splits, true);
+            return readinessManagerFactory(EventEmitter, settings, definitions, true);
         },
         // @TODO review/remove next methods when non-recoverable errors are reworked
         // Called on consumer mode, when storage fails to connect
@@ -133,17 +133,17 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
         init: function () {
-            if (splits.hasInit)
+            if (definitions.hasInit)
                 return;
-            splits.hasInit = true;
-            splits.initCallbacks.forEach(function (cb) { return cb(); });
+            definitions.hasInit = true;
+            definitions.initCallbacks.forEach(function (cb) { return cb(); });
         },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();
             clearTimeout(readyTimeoutId);
             if (!isShared)
-                splits.hasInit = false;
+                definitions.hasInit = false;
         },
         isReady: function () { return isReady; },
         isReadyFromCache: function () { return isReadyFromCache; },

package/esm/readiness/sdkReadinessManager.js

@@ -2,9 +2,8 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
+import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY } from '../logger/constants';
 var NEW_LISTENER_EVENT = 'newListener';
-var REMOVE_LISTENER_EVENT = 'removeListener';
 var TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
@@ -16,21 +15,11 @@ var TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 export function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
     if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, settings); }
     var log = settings.log;
-    /** Ready callback warning */
-    var internalReadyCbCount = 0;
-    var readyCbCount = 0;
-    readinessManager.gate.on(REMOVE_LISTENER_EVENT, function (event) {
-        if (event === SDK_READY)
-            readyCbCount--;
-    });
     readinessManager.gate.on(NEW_LISTENER_EVENT, function (event) {
         if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
             if (readinessManager.isReady()) {
                 log.error(ERROR_CLIENT_LISTENER, [event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
             }
-            else if (event === SDK_READY) {
-                readyCbCount++;
-            }
         }
         else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
             log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
@@ -49,8 +38,6 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
         var promise = promiseWrapper(new Promise(function (resolve, reject) {
             readinessManager.gate.once(SDK_READY, function () {
                 log.info(CLIENT_READY);
-                if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled())
-                    log.warn(CLIENT_NO_LISTENER);
                 resolve();
             });
             readinessManager.gate.once(SDK_READY_TIMED_OUT, function (message) {
@@ -75,9 +62,6 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
         shared: function () {
             return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
         },
-        incInternalReadyCbCount: function () {
-            internalReadyCbCount++;
-        },
         sdkStatus: objectAssign(
         // Expose Event Emitter functionality
         Object.create(readinessManager.gate), {
@@ -92,7 +76,7 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
             ready: function () {
                 if (readinessManager.hasTimedout()) {
                     if (!readinessManager.isReady()) {
-                        return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
+                        return promiseWrapper(Promise.reject(new Error('SDK client has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
                     }
                     else {
                         return Promise.resolve();

package/esm/sdkClient/client.js

@@ -1,12 +1,12 @@
 import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
-import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
+import { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS } from '../utils/constants';
 import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
+import { trackMethodFactory } from './trackMethod';
 var treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 function treatmentsNotReady(featureFlagNames) {
     var evaluations = {};
@@ -15,10 +15,10 @@ function treatmentsNotReady(featureFlagNames) {
     });
     return evaluations;
 }
-function stringify(options) {
-    if (options && options.properties) {
+export function stringify(properties) {
+    if (properties) {
         try {
-            return JSON.stringify(options.properties);
+            return JSON.stringify(properties);
         }
         catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
     }
@@ -27,7 +27,7 @@ function stringify(options) {
  * Creator of base client with getTreatments and track methods.
  */
 export function clientFactory(params) {
-    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker, fallbackTreatmentsCalculator = params.fallbackTreatmentsCalculator;
+    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, telemetryTracker = params.telemetryTracker, fallbackCalculator = params.fallbackCalculator;
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
@@ -36,13 +36,13 @@ export function clientFactory(params) {
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
         var wrapUp = function (evaluationResult) {
             var queue = [];
-            var treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
+            var treatment = processEvaluation(evaluationResult, featureFlagName, key, withConfig, methodName, queue, options);
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatment;
         };
         var evaluation = readinessManager.isReadyFromCache() ?
-            evaluateFeature(log, key, featureFlagName, attributes, storage, options) :
+            evaluateFeature(log, key, featureFlagName, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentNotReady) :
                 treatmentNotReady;
@@ -58,16 +58,15 @@ export function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            evaluateFeatures(log, key, featureFlagNames, attributes, storage, options) :
+            evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentsNotReady(featureFlagNames)) :
                 treatmentsNotReady(featureFlagNames);
@@ -84,16 +83,15 @@ export function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName, options) :
+            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
             isAsync ?
                 Promise.resolve({}) :
                 {};
@@ -109,19 +107,20 @@ export function clientFactory(params) {
         return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
     }
     // Internal function
-    function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
+    function processEvaluation(evaluation, featureFlagName, key, withConfig, invokingMethodName, queue, options) {
+        if (options === void 0) { options = {}; }
         var matchingKey = getMatching(key);
         var bucketingKey = getBucketing(key);
-        var changeNumber = evaluation.changeNumber, impressionsDisabled = evaluation.impressionsDisabled;
+        var definition = evaluation.definition;
         var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
         if (treatment === CONTROL) {
-            var fallbackTreatment = fallbackTreatmentsCalculator(featureFlagName, label);
+            var fallbackTreatment = fallbackCalculator(featureFlagName, label);
             treatment = fallbackTreatment.treatment;
             label = fallbackTreatment.label;
             config = fallbackTreatment.config;
         }
-        if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-            log.info(IMPRESSION_QUEUEING, [featureFlagName, matchingKey, treatment, label]);
+        if (validateDefinitionExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+            log.info(IMPRESSION_QUEUEING, ['Feature flag', featureFlagName, matchingKey, treatment, label]);
             queue.push({
                 imp: {
                     feature: featureFlagName,
@@ -130,10 +129,10 @@ export function clientFactory(params) {
                     time: Date.now(),
                     bucketingKey: bucketingKey,
                     label: label,
-                    changeNumber: changeNumber,
-                    properties: properties
+                    changeNumber: definition === null || definition === void 0 ? void 0 : definition.changeNumber,
+                    properties: stringify(options.properties)
                 },
-                disabled: impressionsDisabled
+                disabled: options.impressionsDisabled || (definition === null || definition === void 0 ? void 0 : definition.impressionsDisabled)
             });
         }
         if (withConfig) {
@@ -144,33 +143,7 @@ export function clientFactory(params) {
         }
         return treatment;
     }
-    function track(key, trafficTypeName, eventTypeId, value, properties, size) {
-        if (size === void 0) { size = 1024; }
-        var stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
-        var matchingKey = getMatching(key);
-        var timestamp = Date.now();
-        var eventData = {
-            eventTypeId: eventTypeId,
-            trafficTypeName: trafficTypeName,
-            value: value,
-            timestamp: timestamp,
-            key: matchingKey,
-            properties: properties
-        };
-        // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-        validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, TRACK_FN_LABEL);
-        var result = eventTracker.track(eventData, size);
-        if (thenable(result)) {
-            return result.then(function (result) {
-                stopTelemetryTracker();
-                return result;
-            });
-        }
-        else {
-            stopTelemetryTracker();
-            return result;
-        }
-    }
+    var track = trackMethodFactory(params);
     return {
         getTreatment: getTreatment,
         getTreatmentWithConfig: getTreatmentWithConfig,

package/esm/sdkClient/clientInputValidation.js

@@ -1,13 +1,13 @@
-import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfReadyFromCache, validateEvaluationOptions } from '../utils/inputValidation';
+import { validateAttributes, validateKey, validateDefinition, validateDefinitions, validateIfNotDestroyed, validateIfReadyFromCache, validateEvaluationOptions } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
-import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
+import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG } from '../utils/constants';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export function clientInputValidationDecorator(settings, client, readinessManager, fallbackTreatmentsCalculator) {
+export function clientInputValidationDecorator(settings, client, readinessManager, fallbackCalculator) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     /**
@@ -18,12 +18,12 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
             validateFlagSets(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
             startsWith(methodName, GET_TREATMENTS) ?
-                validateSplits(log, maybeNameOrNames, methodName) :
-                validateSplit(log, maybeNameOrNames, methodName);
+                validateDefinitions(log, maybeNameOrNames, methodName) :
+                validateDefinition(log, maybeNameOrNames, methodName);
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
         var options = validateEvaluationOptions(log, maybeOptions, methodName);
-        validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
+        validateIfReadyFromCache(log, readinessManager, methodName);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
@@ -39,7 +39,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             featureFlagName.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, withConfig); });
             return res_1;
         }
-        var _a = fallbackTreatmentsCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
+        var _a = fallbackCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
         return withConfig ?
             {
                 treatment: treatment,
@@ -97,17 +97,6 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options) :
             wrapResult({});
     }
-    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-        var key = validateKey(log, maybeKey, TRACK_FN_LABEL);
-        var tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
-        var event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
-        var eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
-        var _a = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
-        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
-        return isNotDestroyed && key && tt && event && eventValue !== false && properties !== false ? // @ts-expect-error
-            client.track(key, tt, event, eventValue, properties, size) :
-            wrapResult(false);
-    }
     return {
         getTreatment: getTreatment,
         getTreatmentWithConfig: getTreatmentWithConfig,
@@ -117,6 +106,6 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
         getTreatmentsByFlagSet: getTreatmentsByFlagSet,
         getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: track
+        track: client.track,
     };
 }

package/esm/sdkClient/sdkClient.js

@@ -1,72 +1,15 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { releaseApiKey, validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
-var COOLDOWN_TIME_IN_MILLIS = 1000;
+import { sdkLifecycleFactory } from './sdkLifecycle';
 /**
  * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 export function sdkClientFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, impressionsTracker = params.impressionsTracker;
-    var hasInit = false;
-    var lastActionTime = 0;
-    function __cooldown(func, time) {
-        var now = Date.now();
-        //get the actual time elapsed in ms
-        var timeElapsed = now - lastActionTime;
-        //check if the time elapsed is less than desired cooldown
-        if (timeElapsed < time) {
-            //if yes, return message with remaining time in seconds
-            settings.log.warn("Flush cooldown, remaining time ".concat((time - timeElapsed) / 1000, " seconds"));
-            return Promise.resolve();
-        }
-        else {
-            //Do the requested action and re-assign the lastActionTime
-            lastActionTime = now;
-            return func();
-        }
-    }
-    function __flush() {
-        return syncManager ? syncManager.flush() : Promise.resolve();
-    }
+    var sdkReadinessManager = params.sdkReadinessManager, settings = params.settings;
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager, params.fallbackTreatmentsCalculator), {
-        init: function () {
-            if (hasInit)
-                return;
-            hasInit = true;
-            if (!isSharedClient) {
-                validateAndTrackApiKey(settings.log, settings.core.authorizationKey);
-                sdkReadinessManager.readinessManager.init();
-                impressionsTracker.start();
-                syncManager && syncManager.start();
-                signalListener && signalListener.start();
-            }
-        },
-        flush: function () {
-            // @TODO define cooldown time
-            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
-        },
-        destroy: function () {
-            hasInit = false;
-            // Mark the SDK as destroyed immediately
-            sdkReadinessManager.readinessManager.destroy();
-            // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
-            if (!isSharedClient) {
-                releaseApiKey(settings.core.authorizationKey);
-                telemetryTracker.sessionLength();
-                signalListener && signalListener.stop();
-                impressionsTracker.stop();
-            }
-            // Stop background jobs
-            syncManager && syncManager.stop();
-            return __flush().then(function () {
-                // Cleanup storage
-                return storage.destroy();
-            });
-        }
-    });
+    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager, params.fallbackCalculator), sdkLifecycleFactory(params, isSharedClient));
 }

package/esm/sdkClient/sdkLifecycle.js

@@ -0,0 +1,70 @@
+import { releaseApiKey, validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
+import { LOCALHOST_MODE } from '../utils/constants';
+var COOLDOWN_TIME_IN_MILLIS = 1000;
+/**
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
+ */
+export function sdkLifecycleFactory(params, isSharedClient) {
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, settings = params.settings, telemetryTracker = params.telemetryTracker, impressionsTracker = params.impressionsTracker, platform = params.platform, serviceApi = params.serviceApi;
+    var hasInit = false;
+    var lastActionTime = 0;
+    var signalListener = platform.SignalListener && settings.mode !== LOCALHOST_MODE ? new platform.SignalListener(params) : undefined;
+    function __cooldown(func, time) {
+        var now = Date.now();
+        //get the actual time elapsed in ms
+        var timeElapsed = now - lastActionTime;
+        //check if the time elapsed is less than desired cooldown
+        if (timeElapsed < time) {
+            //if yes, return message with remaining time in seconds
+            settings.log.warn("Flush cooldown, remaining time ".concat((time - timeElapsed) / 1000, " seconds"));
+            return Promise.resolve();
+        }
+        else {
+            //Do the requested action and re-assign the lastActionTime
+            lastActionTime = now;
+            return func();
+        }
+    }
+    function __flush() {
+        return syncManager ? syncManager.flush() : Promise.resolve();
+    }
+    return {
+        init: function () {
+            if (hasInit)
+                return;
+            hasInit = true;
+            if (!isSharedClient) {
+                validateAndTrackApiKey(settings.log, settings.core.authorizationKey);
+                sdkReadinessManager.readinessManager.init();
+                impressionsTracker.start();
+                syncManager && syncManager.start();
+                signalListener && signalListener.start();
+            }
+        },
+        flush: function () {
+            // @TODO define cooldown time
+            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+        },
+        destroy: function () {
+            hasInit = false;
+            // Mark the SDK as destroyed immediately
+            sdkReadinessManager.readinessManager.destroy();
+            // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
+            if (!isSharedClient) {
+                releaseApiKey(settings.core.authorizationKey);
+                telemetryTracker.sessionLength();
+                signalListener && signalListener.stop();
+                impressionsTracker.stop();
+            }
+            // Stop background jobs
+            syncManager && syncManager.stop();
+            // Stop the service API (the auth provider backoff retries specifically) before flushing,
+            // so that a pending/never-resolved auth retry doesn't block the flush forever
+            serviceApi && serviceApi.stop();
+            return __flush().then(function () {
+                // Cleanup storage
+                return storage.destroy();
+            });
+        }
+    };
+}

package/esm/sdkClient/trackMethod.js

@@ -0,0 +1,52 @@
+import { thenable } from '../utils/promise/thenable';
+import { getMatching } from '../utils/key';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
+import { validateKey, validateTrafficType, validateEvent, validateEventValue, validateEventProperties, validateIfNotDestroyed } from '../utils/inputValidation';
+import { TRACK, TRACK_FN_LABEL } from '../utils/constants';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+/**
+ * Creates a standalone `track` function with input validation.
+ * Reusable by FF SDK client, Configs SDK, and thin-client SDK.
+ */
+export function trackMethodFactory(params, warnTTExistence) {
+    if (warnTTExistence === void 0) { warnTTExistence = true; }
+    var settings = params.settings, definitions = params.storage.definitions, telemetryTracker = params.telemetryTracker, eventTracker = params.eventTracker, readinessManager = params.sdkReadinessManager.readinessManager;
+    var log = settings.log, mode = settings.mode;
+    var isAsync = isConsumerMode(mode);
+    return function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+        // Input validation
+        var key = validateKey(log, maybeKey, TRACK_FN_LABEL);
+        var trafficTypeName = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+        var eventTypeId = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+        var value = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
+        var _a = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
+        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
+        if (!(isNotDestroyed && key && trafficTypeName && eventTypeId && value !== false && properties !== false)) {
+            return isAsync ? Promise.resolve(false) : false;
+        }
+        // Core logic
+        var stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
+        var eventData = {
+            eventTypeId: eventTypeId,
+            trafficTypeName: trafficTypeName,
+            value: value,
+            timestamp: Date.now(),
+            key: getMatching(key),
+            properties: properties
+        };
+        // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
+        if (warnTTExistence)
+            validateTrafficTypeExistence(log, readinessManager, definitions, mode, trafficTypeName, TRACK_FN_LABEL);
+        var result = eventTracker.track(eventData, size);
+        if (thenable(result)) {
+            return result.then(function (result) {
+                stopTelemetryTracker();
+                return result;
+            });
+        }
+        else {
+            stopTelemetryTracker();
+            return result;
+        }
+    };
+}