@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/cjs/utils/inputValidation/target.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTarget = void 0;
+var tslib_1 = require("tslib");
+var lang_1 = require("../lang");
+var key_1 = require("./key");
+var attributes_1 = require("./attributes");
+var constants_1 = require("../../logger/constants");
+function validateTarget(log, maybeTarget, method) {
+    if (!(0, lang_1.isObject)(maybeTarget)) {
+        log.error(constants_1.ERROR_NOT_PLAIN_OBJECT, [method, 'target']);
+        return false;
+    }
+    var key = (0, key_1.validateKey)(log, maybeTarget.key, method);
+    if (key === false)
+        return false;
+    var attributes = (0, attributes_1.validateAttributes)(log, maybeTarget.attributes, method);
+    if (attributes === false)
+        return false;
+    return tslib_1.__assign(tslib_1.__assign({}, maybeTarget), { key: key, attributes: attributes });
+}
+exports.validateTarget = validateTarget;

package/cjs/utils/labels/index.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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;
 var fallbackTreatmentsCalculator_1 = require("../../evaluator/fallbackTreatmentsCalculator");
 exports.SPLIT_KILLED = 'killed';
 exports.NO_CONDITION_MATCH = 'default rule';
-exports.SPLIT_NOT_FOUND = 'definition not found';
+exports.DEFINITION_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_SPLIT_NOT_FOUND = fallbackTreatmentsCalculator_1.FALLBACK_PREFIX + exports.SPLIT_NOT_FOUND;
+exports.FALLBACK_DEFINITION_NOT_FOUND = fallbackTreatmentsCalculator_1.FALLBACK_PREFIX + exports.DEFINITION_NOT_FOUND;

package/cjs/utils/lang/index.js

@@ -200,7 +200,7 @@ function merge(target, source) {
     });
     if (rest && rest.length) {
         var nextSource = rest.splice(0, 1)[0];
-        res = merge.apply(void 0, (0, tslib_1.__spreadArray)([res, nextSource], rest, false));
+        res = merge.apply(void 0, tslib_1.__spreadArray([res, nextSource], rest, false));
     }
     return res;
 }

package/cjs/utils/lang/sets.js

@@ -15,9 +15,9 @@ function returnSetsUnion(set, set2) {
     return new Set(setToArray(set).concat(setToArray(set2)));
 }
 exports.returnSetsUnion = returnSetsUnion;
-function returnDifference(list, list2) {
-    if (list === void 0) { list = []; }
-    if (list2 === void 0) { list2 = []; }
-    return list.filter(function (item) { return list2.indexOf(item) === -1; });
+function returnDifference(list1, list2) {
+    list1 = list1 || [];
+    list2 = list2 || [];
+    return list1.filter(function (item) { return list2.indexOf(item) === -1; });
 }
 exports.returnDifference = returnDifference;

package/cjs/utils/promise/timeout.js

@@ -6,7 +6,7 @@ function timeout(ms, promise) {
         return promise;
     return new Promise(function (resolve, reject) {
         var tid = setTimeout(function () {
-            reject(new Error("Operation timed out because it exceeded the configured time limit of " + ms + " ms."));
+            reject(new Error("Operation timed out because it exceeded the configured time limit of ".concat(ms, " ms.")));
         }, ms);
         promise.then(function (res) {
             clearTimeout(tid);

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 splits_1 = require("../inputValidation/splits");
+var definitions_1 = require("../inputValidation/definitions");
 var constants_1 = require("../../logger/constants");
 var objectAssign_1 = require("../lang/objectAssign");
 var lang_1 = require("../lang");
@@ -45,14 +45,14 @@ function validateFilterType(maybeFilterType) {
  */
 function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
-    var result = (0, splits_1.validateSplits)(log, values, constants_1.LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
+    var result = (0, definitions_1.validateDefinitions)(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);
         }
         // check max length
         if (result.length > maxLength)
-            throw new Error(maxLength + " unique values can be specified at most for '" + type + "' filter. You passed " + result.length + ". Please consider reducing the amount or using other filter.");
+            throw new Error("".concat(maxLength, " unique values can be specified at most for '").concat(type, "' filter. You passed ").concat(result.length, ". Please consider reducing the amount or using other filter."));
         // sort values
         result.sort();
     }
@@ -172,7 +172,7 @@ function validateSplitFilters(log, maybeSplitFilters, mode) {
 }
 exports.validateSplitFilters = validateSplitFilters;
 function validateFlagSets(log, method, flagSets, flagSetsInConfig) {
-    var sets = (0, splits_1.validateSplits)(log, flagSets, method, 'flag sets', 'flag set');
+    var sets = (0, definitions_1.validateDefinitions)(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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.url = void 0;
 var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-var authEndpointMatcher = /^\/v2\/auth/;
+var authEndpointMatcher = /^\/(v2|v3)\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;
 /**
  * Get URL based on a given target (path).
@@ -15,17 +15,17 @@ var streamingEndpointMatcher = /^\/(sse|event-stream)/;
  */
 function url(settings, target) {
     if (telemetryEndpointMatcher.test(target)) {
-        return "" + settings.urls.telemetry + target;
+        return "".concat(settings.urls.telemetry).concat(target);
     }
     if (eventsEndpointMatcher.test(target)) {
-        return "" + settings.urls.events + target;
+        return "".concat(settings.urls.events).concat(target);
     }
     if (authEndpointMatcher.test(target)) {
-        return "" + settings.urls.auth + target;
+        return "".concat(settings.urls.auth).concat(target);
     }
     if (streamingEndpointMatcher.test(target)) {
-        return "" + settings.urls.streaming + target;
+        return "".concat(settings.urls.streaming).concat(target);
     }
-    return "" + settings.urls.sdk + target;
+    return "".concat(settings.urls.sdk).concat(target);
 }
 exports.url = url;

package/esm/evaluator/condition/engineUtils.js

@@ -12,10 +12,10 @@ export function getTreatment(log, key, seed, treatments) {
 /**
  * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
  */
-export function shouldApplyRollout(trafficAllocation, key, trafficAllocationSeed) {
+export function shouldApplyRollout(trafficAllocation, bucketingKey, trafficAllocationSeed) {
     // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.
     if (trafficAllocation < 100) {
-        var _bucket = bucket(key, trafficAllocationSeed);
+        var _bucket = bucket(bucketingKey, trafficAllocationSeed);
         if (_bucket > trafficAllocation) {
             return false;
         }

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

@@ -0,0 +1,64 @@
+import { isObject, isString } from '../../../utils/lang';
+var CONFIG_NAME_DISCARD_REASON = 'Invalid config name (max 100 chars, no spaces)';
+var VARIANT_DISCARD_REASON = 'Invalid variant (max 100 chars and must match pattern)';
+var VALUE_DISCARD_REASON = 'Invalid value (must be an object)';
+var VARIANT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+export function isValidConfigName(name) {
+    return name.length <= 100 && !name.includes(' ');
+}
+export function isValidConfig(config) {
+    if (!isObject(config))
+        return false;
+    if (!isString(config.variant) || config.variant.length > 100 || !VARIANT_PATTERN.test(config.variant))
+        return false;
+    if (!isObject(config.value))
+        return false;
+    return true;
+}
+function sanitizeGlobal(logger, config) {
+    if (config === undefined)
+        return undefined;
+    if (!isValidConfig(config)) {
+        if (!isObject(config) || !isString(config.variant) || config.variant.length > 100 || !VARIANT_PATTERN.test(config.variant)) {
+            logger.error("Fallback configs - Discarded fallback: ".concat(VARIANT_DISCARD_REASON));
+        }
+        else {
+            logger.error("Fallback configs - Discarded fallback: ".concat(VALUE_DISCARD_REASON));
+        }
+        return undefined;
+    }
+    return config;
+}
+function sanitizeByName(logger, byNameFallbacks) {
+    var sanitizedByName = {};
+    if (!isObject(byNameFallbacks))
+        return sanitizedByName;
+    Object.keys(byNameFallbacks).forEach(function (configName) {
+        var config = byNameFallbacks[configName];
+        if (!isValidConfigName(configName)) {
+            logger.error("Fallback configs - Discarded config '".concat(configName, "': ").concat(CONFIG_NAME_DISCARD_REASON));
+            return;
+        }
+        if (!isValidConfig(config)) {
+            if (!isObject(config) || !isString(config.variant) || config.variant.length > 100 || !VARIANT_PATTERN.test(config.variant)) {
+                logger.error("Fallback configs - Discarded config '".concat(configName, "': ").concat(VARIANT_DISCARD_REASON));
+            }
+            else {
+                logger.error("Fallback configs - Discarded config '".concat(configName, "': ").concat(VALUE_DISCARD_REASON));
+            }
+            return;
+        }
+        sanitizedByName[configName] = config;
+    });
+    return sanitizedByName;
+}
+export function sanitizeFallbacks(logger, fallbacks) {
+    if (!isObject(fallbacks)) {
+        logger.error('Fallback configs - Discarded configuration: it must be an object with optional `global` and `byName` properties');
+        return;
+    }
+    return {
+        global: sanitizeGlobal(logger, fallbacks.global),
+        byName: sanitizeByName(logger, fallbacks.byName)
+    };
+}

package/esm/evaluator/fallbackConfigsCalculator/index.js

@@ -0,0 +1,21 @@
+import { CONTROL } from '../../utils/constants';
+export var FALLBACK_PREFIX = 'fallback - ';
+export function FallbackConfigsCalculator(fallbacks) {
+    if (fallbacks === void 0) { fallbacks = {}; }
+    return function (configName, label) {
+        var _a;
+        if (label === void 0) { label = ''; }
+        var fallback = ((_a = fallbacks.byName) === null || _a === void 0 ? void 0 : _a[configName]) || fallbacks.global;
+        return fallback ?
+            {
+                treatment: fallback.variant,
+                config: fallback.value,
+                label: "".concat(FALLBACK_PREFIX).concat(label),
+            } :
+            {
+                treatment: CONTROL,
+                config: null,
+                label: label,
+            };
+    };
+}

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

@@ -1,9 +1,6 @@
 import { isObject, isString } from '../../../utils/lang';
-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 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 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(' ');
@@ -19,7 +16,7 @@ function sanitizeGlobal(logger, treatment) {
     if (treatment === undefined)
         return undefined;
     if (!isValidTreatment(treatment)) {
-        logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
+        logger.error("Fallback treatments - Discarded fallback: ".concat(TREATMENT_DISCARD_REASON));
         return undefined;
     }
     return treatment;
@@ -31,11 +28,11 @@ function sanitizeByFlag(logger, byFlagFallbacks) {
     Object.keys(byFlagFallbacks).forEach(function (flag) {
         var t = byFlagFallbacks[flag];
         if (!isValidFlagName(flag)) {
-            logger.error("Fallback treatments - Discarded flag '" + flag + "': " + FallbackDiscardReason.FlagName);
+            logger.error("Fallback treatments - Discarded flag '".concat(flag, "': ").concat(FLAG_NAME_DISCARD_REASON));
             return;
         }
         if (!isValidTreatment(t)) {
-            logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + FallbackDiscardReason.Treatment);
+            logger.error("Fallback treatments - Discarded treatment for flag '".concat(flag, "': ").concat(TREATMENT_DISCARD_REASON));
             return;
         }
         sanitizedByFlag[flag] = t;

package/esm/evaluator/fallbackTreatmentsCalculator/index.js

@@ -1,40 +1,28 @@
 import { CONTROL } from '../../utils/constants';
 import { isString } from '../../utils/lang';
 export var FALLBACK_PREFIX = 'fallback - ';
-var FallbackTreatmentsCalculator = /** @class */ (function () {
-    function FallbackTreatmentsCalculator(fallbacks) {
-        if (fallbacks === void 0) { fallbacks = {}; }
-        this.fallbacks = fallbacks;
-    }
-    FallbackTreatmentsCalculator.prototype.resolve = function (flagName, label) {
+export function FallbackTreatmentsCalculator(fallbacks) {
+    if (fallbacks === void 0) { fallbacks = {}; }
+    return function (flagName, label) {
         var _a;
-        var treatment = (_a = this.fallbacks.byFlag) === null || _a === void 0 ? void 0 : _a[flagName];
-        if (treatment) {
-            return this.copyWithLabel(treatment, label);
-        }
-        if (this.fallbacks.global) {
-            return this.copyWithLabel(this.fallbacks.global, label);
-        }
-        return {
-            treatment: CONTROL,
-            config: null,
-            label: label,
-        };
-    };
-    FallbackTreatmentsCalculator.prototype.copyWithLabel = function (fallback, label) {
-        if (isString(fallback)) {
-            return {
-                treatment: fallback,
+        if (label === void 0) { label = ''; }
+        var fallback = ((_a = fallbacks.byFlag) === null || _a === void 0 ? void 0 : _a[flagName]) || fallbacks.global;
+        return fallback ?
+            isString(fallback) ?
+                {
+                    treatment: fallback,
+                    config: null,
+                    label: "".concat(FALLBACK_PREFIX).concat(label),
+                } :
+                {
+                    treatment: fallback.treatment,
+                    config: fallback.config,
+                    label: "".concat(FALLBACK_PREFIX).concat(label),
+                } :
+            {
+                treatment: CONTROL,
                 config: null,
-                label: "" + FALLBACK_PREFIX + label,
+                label: label,
             };
-        }
-        return {
-            treatment: fallback.treatment,
-            config: fallback.config,
-            label: "" + FALLBACK_PREFIX + label,
-        };
     };
-    return FallbackTreatmentsCalculator;
-}());
-export { FallbackTreatmentsCalculator };
+}

package/esm/evaluator/index.js

@@ -1,55 +1,60 @@
 import { engineParser } from './Engine';
 import { thenable } from '../utils/promise/thenable';
-import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
+import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_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';
-var treatmentException = {
+var EVALUATION_EXCEPTION = {
     treatment: CONTROL,
     label: EXCEPTION,
     config: null
 };
-function treatmentsException(splitNames) {
+var EVALUATION_DEFINITION_NOT_FOUND = {
+    treatment: CONTROL,
+    label: DEFINITION_NOT_FOUND,
+    config: null
+};
+function treatmentsException(definitionNames) {
     var evaluations = {};
-    splitNames.forEach(function (splitName) {
-        evaluations[splitName] = treatmentException;
+    definitionNames.forEach(function (definitionName) {
+        evaluations[definitionName] = EVALUATION_EXCEPTION;
     });
     return evaluations;
 }
-export function evaluateFeature(log, key, splitName, attributes, storage, options) {
-    var parsedSplit;
+export function evaluateFeature(log, key, definitionName, attributes, storage, options) {
+    var definition;
     try {
-        parsedSplit = storage.splits.getSplit(splitName);
+        definition = storage.definitions.get(definitionName);
     }
     catch (e) {
-        // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
-        return treatmentException;
+        // Exception on sync storage. Not possible ATM with InMemory and InLocal storages.
+        return EVALUATION_EXCEPTION;
     }
-    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
+    if (thenable(definition)) {
+        return definition.then(function (definition) { return getEvaluation(log, key, definition, attributes, storage, options); }).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 treatmentException; });
+        function () { return EVALUATION_EXCEPTION; });
     }
-    return getEvaluation(log, key, parsedSplit, attributes, storage, options);
+    return getEvaluation(log, key, definition, attributes, storage, options);
 }
-export function evaluateFeatures(log, key, splitNames, attributes, storage, options) {
-    var parsedSplits;
+export function evaluateFeatures(log, key, definitionNames, attributes, storage, options) {
+    var definitions;
     try {
-        parsedSplits = storage.splits.getSplits(splitNames);
+        definitions = storage.definitions.getMany(definitionNames);
     }
     catch (e) {
-        // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
-        return treatmentsException(splitNames);
+        // Exception on sync storage. Not possible ATM with InMemory and InLocal storages.
+        return treatmentsException(definitionNames);
     }
-    return thenable(parsedSplits) ?
-        parsedSplits.then(function (splits) { return getEvaluations(log, key, splitNames, splits, attributes, storage, options); })
+    return thenable(definitions) ?
+        definitions.then(function (definitions) { return getEvaluations(log, key, definitionNames, definitions, attributes, storage, options); })
             .catch(function () {
-            // Exception on async `getSplits` storage. For example, when the storage is redis or
+            // 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
-            return treatmentsException(splitNames);
+            return treatmentsException(definitionNames);
         }) :
-        getEvaluations(log, key, splitNames, parsedSplits, attributes, storage, options);
+        getEvaluations(log, key, definitionNames, definitions, attributes, storage, options);
 }
 export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method, options) {
     var storedFlagNames;
@@ -70,7 +75,7 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
     }
     // get features by flag sets
     try {
-        storedFlagNames = storage.splits.getNamesByFlagSets(flagSets);
+        storedFlagNames = storage.definitions.getNamesBySets(flagSets);
     }
     catch (e) {
         // return empty evaluations
@@ -84,47 +89,66 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
         }) :
         evaluate(storedFlagNames);
 }
-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
+function getEvaluation(log, key, definition, attributes, storage, options) {
+    if (definition) {
+        var split = engineParser(log, definition, storage);
+        var evaluation = split.getTreatment(key, attributes, evaluateFeature);
+        // If the storage is async and the evaluated definition 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;
+                result.changeNumber = definition.changeNumber;
+                result.config = definition.configurations && definition.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;
+                result.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || definition.impressionsDisabled;
                 return result;
             });
         }
         else {
-            evaluation.changeNumber = splitJSON.changeNumber;
-            evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
+            evaluation.changeNumber = definition.changeNumber;
+            evaluation.config = definition.configurations && definition.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;
+            evaluation.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || definition.impressionsDisabled;
         }
+        return evaluation;
     }
-    return evaluation;
+    return EVALUATION_DEFINITION_NOT_FOUND;
 }
-function getEvaluations(log, key, splitNames, splits, attributes, storage, options) {
+function getEvaluations(log, key, definitionNames, definitions, attributes, storage, options) {
     var result = {};
     var thenables = [];
-    splitNames.forEach(function (splitName) {
-        var evaluation = getEvaluation(log, key, splits[splitName], attributes, storage, options);
+    definitionNames.forEach(function (definitionName) {
+        var evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage, options);
         if (thenable(evaluation)) {
             thenables.push(evaluation.then(function (res) {
-                result[splitName] = res;
+                result[definitionName] = res;
             }));
         }
         else {
-            result[splitName] = evaluation;
+            result[definitionName] = 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,
+            config: definition.configurations && definition.configurations[definition.defaultTreatment] || null,
+            changeNumber: definition.changeNumber
+        };
+    }
+    return EVALUATION_DEFINITION_NOT_FOUND;
+}

package/esm/evaluator/matchers/whitelist.js

@@ -1,5 +1,5 @@
 export function whitelistMatcherContext(ruleAttr) {
-    var whitelistSet = new Set(ruleAttr);
+    var whitelistSet = new Set(ruleAttr || []);
     return function whitelistMatcher(runtimeAttr) {
         var isInWhitelist = whitelistSet.has(runtimeAttr);
         return isInWhitelist;

package/esm/integrations/pluggable.js

@@ -13,7 +13,7 @@ export function pluggableIntegrationsManagerFactory(integrations, params) {
     // No need to check if `settings.integrations` is an array of functions. It was already validated
     integrations.forEach(function (integrationFactory) {
         var integration = integrationFactory(params);
-        if (integration && integration.queue)
+        if (integration)
             listeners.push(integration);
     });
     // If `listeners` is empty, not return a integration manager

package/esm/listeners/browser.js

@@ -10,14 +10,15 @@ var EVENT_NAME = 'for visibilitychange and pagehide events.';
  * We'll listen for events over the window object.
  */
 var BrowserSignalListener = /** @class */ (function () {
-    function BrowserSignalListener(syncManager, settings, storage, serviceApi) {
+    function BrowserSignalListener(_a) {
+        var syncManager = _a.syncManager, settings = _a.settings, storage = _a.storage, splitApi = _a.splitApi, entityType = _a.entityType;
         this.syncManager = syncManager;
         this.settings = settings;
         this.storage = storage;
-        this.serviceApi = serviceApi;
+        this.serviceApi = splitApi;
         this.flushData = this.flushData.bind(this);
         this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
-        this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
+        this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled, entityType);
     }
     /**
      * start method.

package/esm/listeners/node.js

@@ -10,8 +10,8 @@ var EVENT_NAME = 'for SIGTERM signal.';
  * the process is already exiting.
  */
 var NodeSignalListener = /** @class */ (function () {
-    function NodeSignalListener(syncManager, // private handler: () => MaybeThenable<void>,
-    settings) {
+    function NodeSignalListener(_a) {
+        var syncManager = _a.syncManager, settings = _a.settings;
         // @TODO review handler logic when implementing Node.js SDK
         this.handler = function () {
             if (syncManager) {
@@ -44,13 +44,13 @@ var NodeSignalListener = /** @class */ (function () {
             // eslint-disable-next-line no-undef
             process.kill(process.pid, SIGTERM);
         };
-        this.settings.log.debug(LOG_PREFIX_CLEANUP + "Split SDK graceful shutdown after SIGTERM.");
+        this.settings.log.debug("".concat(LOG_PREFIX_CLEANUP, "Split SDK graceful shutdown after SIGTERM."));
         var handlerResult = null;
         try {
             handlerResult = this.handler();
         }
         catch (err) {
-            this.settings.log.error(LOG_PREFIX_CLEANUP + "Error with Split SDK graceful shutdown: " + err);
+            this.settings.log.error("".concat(LOG_PREFIX_CLEANUP, "Error with Split SDK graceful shutdown: ").concat(err));
         }
         if (thenable(handlerResult)) {
             // Always exit, even with errors. The promise is returned for UT purposes.