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

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -107,17 +107,18 @@ function telemetrySubmitterFactory(params) {
     var telemetry = params.storage.telemetry, now = params.platform.now;
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, serviceApi = params.serviceApi, readiness = params.readiness;
+    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var stopTimer = (0, timer_1.timer)(now);
-    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, serviceApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
+    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
+    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(constants_2.SDK_READY, function () {
         telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started
         if (submitter.isRunning()) {
-            var postMetricsConfigTask = (0, submitter_1.submitterFactory)(log, serviceApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
+            var postMetricsConfigTask = (0, submitter_1.submitterFactory)(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
             postMetricsConfigTask.execute();
         }
     });

package/cjs/sync/submitters/uniqueKeysSubmitter.js

@@ -8,7 +8,7 @@ var UNIQUE_KEYS_RATE = 900000; // 15 minutes
  * Submitter that periodically posts impression counts
  */
 function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.serviceApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
     var syncTask = (0, submitter_1.submitterFactory)(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE);

package/cjs/sync/syncManagerOnline.js

@@ -7,9 +7,7 @@ var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
 var constants_3 = require("../utils/constants");
 var constants_4 = require("../readiness/constants");
-var AbstractDefinitionsCacheSync_1 = require("../storages/AbstractDefinitionsCacheSync");
-var splitChangesFetcher_1 = require("./polling/fetchers/splitChangesFetcher");
-var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher");
+var AbstractSplitsCacheSync_1 = require("../storages/AbstractSplitsCacheSync");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -17,24 +15,21 @@ var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher"
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
-function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
-    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(params.serviceApi.fetchSegmentChanges); }; }
+function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
     return function (params) {
         var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
         var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
-        // It is not injected as push and polling managers, because at the moment it is required
+        // It is not inyected as push and polling managers, because at the moment it is required
         var submitterManager = (0, submitterManager_1.submitterManagerFactory)(params);
         /** Sync Manager logic */
         function startPolling() {
@@ -82,7 +77,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, def
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.definitions.emit(constants_4.SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
+                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
                         }
                     }
                     // start syncing splits and segments
@@ -141,7 +136,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, def
                         if (pushManager) {
                             if (pollingManager.isRunning()) {
                                 // if doing polling, we must start the periodic fetch of data
-                                if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+                                if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                                     mySegmentsSyncTask.start();
                             }
                             else {
@@ -151,7 +146,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, def
                             }
                         }
                         else {
-                            if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+                            if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                                 mySegmentsSyncTask.start();
                         }
                     }

package/cjs/utils/Backoff.js

@@ -27,26 +27,6 @@ var Backoff = /** @class */ (function () {
         this.attempts++;
         return delayInMillis;
     };
-    /**
-     * Schedule a delayed call to `cb`
-     * @returns a promise that resolves/rejects with the result of the `cb` function, which must return a promise.
-     */
-    Backoff.prototype.scheduleCallAsync = function () {
-        var _this = this;
-        var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
-        if (this.timeoutID)
-            clearTimeout(this.timeoutID);
-        this.attempts++;
-        return new Promise(function (resolve, reject) {
-            _this.timeoutID = setTimeout(function () {
-                _this.timeoutID = undefined;
-                _this.cb().then(resolve, reject);
-            }, delayInMillis);
-        });
-    };
-    /**
-     * Reset the backoff attempts
-     */
     Backoff.prototype.reset = function () {
         this.attempts = 0;
         if (this.timeoutID) {

package/cjs/utils/inputValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateEvaluationOptions = exports.validateTrafficTypeExistence = exports.validateDefinitionExistence = exports.validateIfOperational = exports.validateIfReadyFromCache = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateDefinitions = exports.validateDefinition = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
+exports.validateEvaluationOptions = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfReadyFromCache = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
 var apiKey_1 = require("./apiKey");
 Object.defineProperty(exports, "validateApiKey", { enumerable: true, get: function () { return apiKey_1.validateApiKey; } });
 Object.defineProperty(exports, "validateAndTrackApiKey", { enumerable: true, get: function () { return apiKey_1.validateAndTrackApiKey; } });
@@ -15,18 +15,18 @@ var eventProperties_1 = require("./eventProperties");
 Object.defineProperty(exports, "validateEventProperties", { enumerable: true, get: function () { return eventProperties_1.validateEventProperties; } });
 var key_1 = require("./key");
 Object.defineProperty(exports, "validateKey", { enumerable: true, get: function () { return key_1.validateKey; } });
-var definition_1 = require("./definition");
-Object.defineProperty(exports, "validateDefinition", { enumerable: true, get: function () { return definition_1.validateDefinition; } });
-var definitions_1 = require("./definitions");
-Object.defineProperty(exports, "validateDefinitions", { enumerable: true, get: function () { return definitions_1.validateDefinitions; } });
+var split_1 = require("./split");
+Object.defineProperty(exports, "validateSplit", { enumerable: true, get: function () { return split_1.validateSplit; } });
+var splits_1 = require("./splits");
+Object.defineProperty(exports, "validateSplits", { enumerable: true, get: function () { return splits_1.validateSplits; } });
 var trafficType_1 = require("./trafficType");
 Object.defineProperty(exports, "validateTrafficType", { enumerable: true, get: function () { return trafficType_1.validateTrafficType; } });
 var isOperational_1 = require("./isOperational");
 Object.defineProperty(exports, "validateIfNotDestroyed", { enumerable: true, get: function () { return isOperational_1.validateIfNotDestroyed; } });
 Object.defineProperty(exports, "validateIfReadyFromCache", { enumerable: true, get: function () { return isOperational_1.validateIfReadyFromCache; } });
 Object.defineProperty(exports, "validateIfOperational", { enumerable: true, get: function () { return isOperational_1.validateIfOperational; } });
-var definitionExistence_1 = require("./definitionExistence");
-Object.defineProperty(exports, "validateDefinitionExistence", { enumerable: true, get: function () { return definitionExistence_1.validateDefinitionExistence; } });
+var splitExistence_1 = require("./splitExistence");
+Object.defineProperty(exports, "validateSplitExistence", { enumerable: true, get: function () { return splitExistence_1.validateSplitExistence; } });
 var trafficTypeExistence_1 = require("./trafficTypeExistence");
 Object.defineProperty(exports, "validateTrafficTypeExistence", { enumerable: true, get: function () { return trafficTypeExistence_1.validateTrafficTypeExistence; } });
 var eventProperties_2 = require("./eventProperties");

package/cjs/utils/inputValidation/isOperational.js

@@ -9,15 +9,15 @@ function validateIfNotDestroyed(log, readinessManager, method) {
     return false;
 }
 exports.validateIfNotDestroyed = validateIfNotDestroyed;
-function validateIfReadyFromCache(log, readinessManager, method) {
+function validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames) {
     if (readinessManager.isReadyFromCache())
         return true;
-    log.warn(constants_1.CLIENT_NOT_READY_FROM_CACHE, [method]);
+    log.warn(constants_1.CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag ".concat(featureFlagNameOrNames.toString()) : '']);
     return false;
 }
 exports.validateIfReadyFromCache = validateIfReadyFromCache;
 // Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
-function validateIfOperational(log, readinessManager, method) {
-    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method);
+function validateIfOperational(log, readinessManager, method, featureFlagNameOrNames) {
+    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
 }
 exports.validateIfOperational = validateIfOperational;

package/cjs/utils/inputValidation/{definition.js → split.js}

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDefinition = void 0;
+exports.validateSplit = void 0;
 var constants_1 = require("../../logger/constants");
 var lang_1 = require("../lang");
 // include BOM and nbsp
 var TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
-function validateDefinition(log, maybeDefinition, method, item) {
+function validateSplit(log, maybeSplit, method, item) {
     if (item === void 0) { item = 'feature flag name'; }
-    if (maybeDefinition == undefined) { // eslint-disable-line eqeqeq
+    if (maybeSplit == undefined) { // eslint-disable-line eqeqeq
         log.error(constants_1.ERROR_NULL, [method, item]);
     }
-    else if (!(0, lang_1.isString)(maybeDefinition)) {
+    else if (!(0, lang_1.isString)(maybeSplit)) {
         log.error(constants_1.ERROR_INVALID, [method, item]);
     }
     else {
-        if (TRIMMABLE_SPACES_REGEX.test(maybeDefinition)) {
-            log.warn(constants_1.WARN_TRIMMING, [method, item, maybeDefinition]);
-            maybeDefinition = maybeDefinition.trim();
+        if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
+            log.warn(constants_1.WARN_TRIMMING, [method, item, maybeSplit]);
+            maybeSplit = maybeSplit.trim();
         }
-        if (maybeDefinition.length > 0) {
-            return maybeDefinition;
+        if (maybeSplit.length > 0) {
+            return maybeSplit;
         }
         else {
             log.error(constants_1.ERROR_EMPTY, [method, item]);
@@ -27,4 +27,4 @@ function validateDefinition(log, maybeDefinition, method, item) {
     }
     return false;
 }
-exports.validateDefinition = validateDefinition;
+exports.validateSplit = validateSplit;

package/cjs/utils/inputValidation/{definitionExistence.js → splitExistence.js}

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDefinitionExistence = void 0;
+exports.validateSplitExistence = void 0;
 var labels_1 = require("../labels");
 var constants_1 = require("../../logger/constants");
 /**
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a definition twice.
+ * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
-function validateDefinitionExistence(log, readinessManager, definitionName, labelOrDefinitionObj, method) {
+function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
     if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
-        if (labelOrDefinitionObj === labels_1.DEFINITION_NOT_FOUND || labelOrDefinitionObj === labels_1.FALLBACK_DEFINITION_NOT_FOUND || labelOrDefinitionObj == null) {
-            log.warn(constants_1.WARN_NOT_EXISTENT_DEFINITION, [method, definitionName]);
+        if (labelOrSplitObj === labels_1.SPLIT_NOT_FOUND || labelOrSplitObj === labels_1.FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
+            log.warn(constants_1.WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
             return false;
         }
     }
     return true;
 }
-exports.validateDefinitionExistence = validateDefinitionExistence;
+exports.validateSplitExistence = validateSplitExistence;

package/cjs/utils/inputValidation/splits.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSplits = void 0;
+var constants_1 = require("../../logger/constants");
+var lang_1 = require("../lang");
+var split_1 = require("./split");
+function validateSplits(log, maybeSplits, method, listName, item) {
+    if (listName === void 0) { listName = 'feature flag names'; }
+    if (item === void 0) { item = 'feature flag name'; }
+    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
+        var validatedArray_1 = [];
+        // Remove invalid values
+        maybeSplits.forEach(function (maybeSplit) {
+            var splitName = (0, split_1.validateSplit)(log, maybeSplit, method, item);
+            if (splitName)
+                validatedArray_1.push(splitName);
+        });
+        // Strip off duplicated values if we have valid split names then return
+        if (validatedArray_1.length)
+            return (0, lang_1.uniq)(validatedArray_1);
+    }
+    log.error(constants_1.ERROR_EMPTY_ARRAY, [method, listName]);
+    return false;
+}
+exports.validateSplits = validateSplits;

package/cjs/utils/labels/index.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FALLBACK_DEFINITION_NOT_FOUND = exports.PREREQUISITES_NOT_MET = exports.UNSUPPORTED_MATCHER_TYPE = exports.NOT_IN_SPLIT = exports.SPLIT_ARCHIVED = exports.EXCEPTION = exports.SDK_NOT_READY = exports.DEFINITION_NOT_FOUND = exports.NO_CONDITION_MATCH = exports.SPLIT_KILLED = void 0;
+exports.FALLBACK_SPLIT_NOT_FOUND = exports.PREREQUISITES_NOT_MET = exports.UNSUPPORTED_MATCHER_TYPE = exports.NOT_IN_SPLIT = exports.SPLIT_ARCHIVED = exports.EXCEPTION = exports.SDK_NOT_READY = exports.SPLIT_NOT_FOUND = exports.NO_CONDITION_MATCH = exports.SPLIT_KILLED = void 0;
 var fallbackTreatmentsCalculator_1 = require("../../evaluator/fallbackTreatmentsCalculator");
 exports.SPLIT_KILLED = 'killed';
 exports.NO_CONDITION_MATCH = 'default rule';
-exports.DEFINITION_NOT_FOUND = 'definition not found';
+exports.SPLIT_NOT_FOUND = 'definition not found';
 exports.SDK_NOT_READY = 'not ready';
 exports.EXCEPTION = 'exception';
 exports.SPLIT_ARCHIVED = 'archived';
 exports.NOT_IN_SPLIT = 'not in split';
 exports.UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 exports.PREREQUISITES_NOT_MET = 'prerequisites not met';
-exports.FALLBACK_DEFINITION_NOT_FOUND = fallbackTreatmentsCalculator_1.FALLBACK_PREFIX + exports.DEFINITION_NOT_FOUND;
+exports.FALLBACK_SPLIT_NOT_FOUND = fallbackTreatmentsCalculator_1.FALLBACK_PREFIX + exports.SPLIT_NOT_FOUND;

package/cjs/utils/settingsValidation/index.js

@@ -55,8 +55,6 @@ exports.base = {
         streaming: 'https://streaming.split.io',
         // Telemetry Server
         telemetry: 'https://telemetry.split.io/api',
-        // Configs Server
-        configs: 'https://configs.split.io',
     },
     // Defines which kind of storage we should instantiate.
     storage: undefined,

package/cjs/utils/settingsValidation/splitFilters.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateFlagSets = exports.validateSplitFilters = void 0;
-var definitions_1 = require("../inputValidation/definitions");
+var splits_1 = require("../inputValidation/splits");
 var constants_1 = require("../../logger/constants");
 var objectAssign_1 = require("../lang/objectAssign");
 var lang_1 = require("../lang");
@@ -45,7 +45,7 @@ function validateFilterType(maybeFilterType) {
  */
 function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
-    var result = (0, definitions_1.validateDefinitions)(log, values, constants_1.LOG_PREFIX_SETTINGS, "".concat(type, " filter"), "".concat(type, " filter value"));
+    var result = (0, splits_1.validateSplits)(log, values, constants_1.LOG_PREFIX_SETTINGS, "".concat(type, " filter"), "".concat(type, " filter value"));
     if (result) {
         if (type === 'bySet') {
             result = sanitizeFlagSets(log, result, constants_1.LOG_PREFIX_SETTINGS);
@@ -172,7 +172,7 @@ function validateSplitFilters(log, maybeSplitFilters, mode) {
 }
 exports.validateSplitFilters = validateSplitFilters;
 function validateFlagSets(log, method, flagSets, flagSetsInConfig) {
-    var sets = (0, definitions_1.validateDefinitions)(log, flagSets, method, 'flag sets', 'flag set');
+    var sets = (0, splits_1.validateSplits)(log, flagSets, method, 'flag sets', 'flag set');
     var toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
     if (flagSetsInConfig.length > 0) {
         toReturn = toReturn.filter(function (flagSet) {

package/cjs/utils/settingsValidation/url.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.url = void 0;
-var telemetryEndpointMatcher = /^\/v1\/(metrics|keys)\/(config|usage|ss|cs)/;
+var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-var authEndpointMatcher = /^\/(v2|v3)\/auth/;
+var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;
-var configsEndpointMatcher = /^\/v1\/(configs|segmentChanges)/;
 /**
  * Get URL based on a given target (path).
  * ATM, it is only used for testing purposes.
@@ -27,9 +26,6 @@ function url(settings, target) {
     if (streamingEndpointMatcher.test(target)) {
         return "".concat(settings.urls.streaming).concat(target);
     }
-    if (configsEndpointMatcher.test(target)) {
-        return "".concat(settings.urls.configs).concat(target);
-    }
     return "".concat(settings.urls.sdk).concat(target);
 }
 exports.url = url;

package/esm/evaluator/condition/index.js

@@ -7,7 +7,7 @@ function match(log, matchingResult, bucketingKey, seed, treatments, label) {
         return treatments ? // Feature flag
             {
                 treatment: getTreatment(log, bucketingKey, seed, treatments),
-                label: label !== null && label !== void 0 ? label : ''
+                label: label
             } : // Rule-based segment
             true;
     }
@@ -20,7 +20,7 @@ export function conditionContext(log, matcherEvaluator, treatments, label, condi
         // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
         if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation, key.bucketingKey, trafficAllocationSeed)) {
             return {
-                // treatment value is assigned later, at Engine's evaluationResult
+                treatment: undefined,
                 label: NOT_IN_SPLIT
             };
         }

package/esm/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.js

@@ -1,6 +1,9 @@
 import { isObject, isString } from '../../../utils/lang';
-var FLAG_NAME_DISCARD_REASON = 'Invalid flag name (max 100 chars, no spaces)';
-var TREATMENT_DISCARD_REASON = 'Invalid treatment (max 100 chars and must match pattern)';
+var FallbackDiscardReason;
+(function (FallbackDiscardReason) {
+    FallbackDiscardReason["FlagName"] = "Invalid flag name (max 100 chars, no spaces)";
+    FallbackDiscardReason["Treatment"] = "Invalid treatment (max 100 chars and must match pattern)";
+})(FallbackDiscardReason || (FallbackDiscardReason = {}));
 var TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
 export function isValidFlagName(name) {
     return name.length <= 100 && !name.includes(' ');
@@ -16,7 +19,7 @@ function sanitizeGlobal(logger, treatment) {
     if (treatment === undefined)
         return undefined;
     if (!isValidTreatment(treatment)) {
-        logger.error("Fallback treatments - Discarded fallback: ".concat(TREATMENT_DISCARD_REASON));
+        logger.error("Fallback treatments - Discarded fallback: ".concat(FallbackDiscardReason.Treatment));
         return undefined;
     }
     return treatment;
@@ -28,11 +31,11 @@ function sanitizeByFlag(logger, byFlagFallbacks) {
     Object.keys(byFlagFallbacks).forEach(function (flag) {
         var t = byFlagFallbacks[flag];
         if (!isValidFlagName(flag)) {
-            logger.error("Fallback treatments - Discarded flag '".concat(flag, "': ").concat(FLAG_NAME_DISCARD_REASON));
+            logger.error("Fallback treatments - Discarded flag '".concat(flag, "': ").concat(FallbackDiscardReason.FlagName));
             return;
         }
         if (!isValidTreatment(t)) {
-            logger.error("Fallback treatments - Discarded treatment for flag '".concat(flag, "': ").concat(TREATMENT_DISCARD_REASON));
+            logger.error("Fallback treatments - Discarded treatment for flag '".concat(flag, "': ").concat(FallbackDiscardReason.Treatment));
             return;
         }
         sanitizedByFlag[flag] = t;

package/esm/evaluator/index.js

@@ -1,62 +1,57 @@
 import { engineParser } from './Engine';
 import { thenable } from '../utils/promise/thenable';
-import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_NOT_FOUND } from '../utils/labels';
+import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
 import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
-import { objectAssign } from '../utils/lang/objectAssign';
-var EVALUATION_EXCEPTION = {
+var treatmentException = {
     treatment: CONTROL,
     label: EXCEPTION,
     config: null
 };
-var EVALUATION_DEFINITION_NOT_FOUND = {
-    treatment: CONTROL,
-    label: DEFINITION_NOT_FOUND,
-    config: null
-};
-function treatmentsException(definitionNames) {
+function treatmentsException(splitNames) {
     var evaluations = {};
-    definitionNames.forEach(function (definitionName) {
-        evaluations[definitionName] = EVALUATION_EXCEPTION;
+    splitNames.forEach(function (splitName) {
+        evaluations[splitName] = treatmentException;
     });
     return evaluations;
 }
-export function evaluateFeature(log, key, definitionName, attributes, storage) {
-    var definition;
+export function evaluateFeature(log, key, splitName, attributes, storage, options) {
+    var parsedSplit;
     try {
-        definition = storage.definitions.get(definitionName);
+        parsedSplit = storage.splits.getSplit(splitName);
     }
     catch (e) {
-        // Exception on sync storage. Not possible ATM with InMemory and InLocal storages.
-        return EVALUATION_EXCEPTION;
+        // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
+        return treatmentException;
     }
-    return thenable(definition) ?
-        definition.then(function (definition) { return getEvaluation(log, key, definition, attributes, storage); })
-            .catch(
-        // Exception on async storage. For example, when the storage is redis or
+    if (thenable(parsedSplit)) {
+        return parsedSplit.then(function (split) { return getEvaluation(log, key, split, attributes, storage, options); }).catch(
+        // Exception on async `getSplit` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-        function () { return EVALUATION_EXCEPTION; }) :
-        getEvaluation(log, key, definition, attributes, storage);
+        function () { return treatmentException; });
+    }
+    return getEvaluation(log, key, parsedSplit, attributes, storage, options);
 }
-export function evaluateFeatures(log, key, definitionNames, attributes, storage) {
-    var definitions;
+export function evaluateFeatures(log, key, splitNames, attributes, storage, options) {
+    var parsedSplits;
     try {
-        definitions = storage.definitions.getMany(definitionNames);
+        parsedSplits = storage.splits.getSplits(splitNames);
     }
     catch (e) {
-        // Exception on sync storage. Not possible ATM with InMemory and InLocal storages.
-        return treatmentsException(definitionNames);
+        // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
+        return treatmentsException(splitNames);
     }
-    return thenable(definitions) ?
-        definitions.then(function (definitions) { return getEvaluations(log, key, definitionNames, definitions, attributes, storage); })
-            .catch(
-        // Exception on async storage. For example, when the storage is redis or
-        // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-        function () { return treatmentsException(definitionNames); }) :
-        getEvaluations(log, key, definitionNames, definitions, attributes, storage);
+    return thenable(parsedSplits) ?
+        parsedSplits.then(function (splits) { return getEvaluations(log, key, splitNames, splits, attributes, storage, options); })
+            .catch(function () {
+            // Exception on async `getSplits` storage. For example, when the storage is redis or
+            // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
+            return treatmentsException(splitNames);
+        }) :
+        getEvaluations(log, key, splitNames, parsedSplits, attributes, storage, options);
 }
-export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method) {
+export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method, options) {
     var storedFlagNames;
     function evaluate(featureFlagsByFlagSets) {
         var featureFlags = new Set();
@@ -70,12 +65,12 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
+            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage, options) :
             {};
     }
     // get features by flag sets
     try {
-        storedFlagNames = storage.definitions.getNamesBySets(flagSets);
+        storedFlagNames = storage.splits.getNamesByFlagSets(flagSets);
     }
     catch (e) {
         // return empty evaluations
@@ -84,51 +79,52 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
     // evaluate related features
     return thenable(storedFlagNames) ?
         storedFlagNames.then(function (storedFlagNames) { return evaluate(storedFlagNames); })
-            .catch(function () { return ({}); }) :
+            .catch(function () {
+            return {};
+        }) :
         evaluate(storedFlagNames);
 }
-function getEvaluation(log, key, definition, attributes, storage) {
-    if (definition) {
-        var split = engineParser(log, definition, storage);
-        var evaluation = split.getTreatment(key, attributes, evaluateFeature);
-        return thenable(evaluation) ?
-            evaluation.then(function (result) { return objectAssign(result, { definition: definition }); }) :
-            objectAssign(evaluation, { definition: definition });
+function getEvaluation(log, key, splitJSON, attributes, storage, options) {
+    var evaluation = {
+        treatment: CONTROL,
+        label: SPLIT_NOT_FOUND,
+        config: null
+    };
+    if (splitJSON) {
+        var split = engineParser(log, splitJSON, storage);
+        evaluation = split.getTreatment(key, attributes, evaluateFeature);
+        // If the storage is async and the evaluated flag uses segments or dependencies, evaluation is thenable
+        if (thenable(evaluation)) {
+            return evaluation.then(function (result) {
+                result.changeNumber = splitJSON.changeNumber;
+                result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
+                // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
+                result.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || splitJSON.impressionsDisabled;
+                return result;
+            });
+        }
+        else {
+            evaluation.changeNumber = splitJSON.changeNumber;
+            evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
+            // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
+            evaluation.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || splitJSON.impressionsDisabled;
+        }
     }
-    return EVALUATION_DEFINITION_NOT_FOUND;
+    return evaluation;
 }
-function getEvaluations(log, key, definitionNames, definitions, attributes, storage) {
+function getEvaluations(log, key, splitNames, splits, attributes, storage, options) {
     var result = {};
     var thenables = [];
-    definitionNames.forEach(function (definitionName) {
-        var evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage);
-        thenable(evaluation) ?
+    splitNames.forEach(function (splitName) {
+        var evaluation = getEvaluation(log, key, splits[splitName], attributes, storage, options);
+        if (thenable(evaluation)) {
             thenables.push(evaluation.then(function (res) {
-                result[definitionName] = res;
-            })) :
-            result[definitionName] = evaluation;
+                result[splitName] = res;
+            }));
+        }
+        else {
+            result[splitName] = evaluation;
+        }
     });
     return thenables.length > 0 ? Promise.all(thenables).then(function () { return result; }) : result;
 }
-export function evaluateDefaultTreatment(definitionName, storage) {
-    var definition;
-    try {
-        definition = storage.definitions.get(definitionName);
-    }
-    catch (e) {
-        return EVALUATION_EXCEPTION;
-    }
-    return thenable(definition) ?
-        definition.then(getDefaultTreatment).catch(function () { return EVALUATION_EXCEPTION; }) :
-        getDefaultTreatment(definition);
-}
-function getDefaultTreatment(definition) {
-    if (definition) {
-        return {
-            treatment: definition.defaultTreatment,
-            label: NO_CONDITION_MATCH,
-            definition: definition,
-        };
-    }
-    return EVALUATION_DEFINITION_NOT_FOUND;
-}

package/esm/listeners/browser.js

@@ -10,8 +10,7 @@ var EVENT_NAME = 'for visibilitychange and pagehide events.';
  * We'll listen for events over the window object.
  */
 var BrowserSignalListener = /** @class */ (function () {
-    function BrowserSignalListener(_a) {
-        var syncManager = _a.syncManager, settings = _a.settings, storage = _a.storage, serviceApi = _a.serviceApi;
+    function BrowserSignalListener(syncManager, settings, storage, serviceApi) {
         this.syncManager = syncManager;
         this.settings = settings;
         this.storage = storage;