@splitsoftware/splitio-commons 2.11.1-rc.2 → 3.0.0-rc.0

package/cjs/utils/inputValidation/attribute.js

@@ -4,7 +4,7 @@ exports.validateAttribute = void 0;
 var lang_1 = require("../../utils/lang");
 function validateAttribute(log, attributeKey, attributeValue, method) {
     if (!(0, lang_1.isString)(attributeKey) || attributeKey.length === 0) {
-        log.warn(method + ": you passed an invalid attribute name, attribute name must be a non-empty string.");
+        log.warn("".concat(method, ": you passed an invalid attribute name, attribute name must be a non-empty string."));
         return false;
     }
     var isStringVal = (0, lang_1.isString)(attributeValue);
@@ -12,7 +12,7 @@ function validateAttribute(log, attributeKey, attributeValue, method) {
     var isBoolVal = (0, lang_1.isBoolean)(attributeValue);
     var isArrayVal = Array.isArray(attributeValue);
     if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
-        log.warn(method + ": you passed an invalid attribute value for " + attributeKey + ". Acceptable types are: string, number, boolean and array of strings.");
+        log.warn("".concat(method, ": you passed an invalid attribute value for ").concat(attributeKey, ". Acceptable types are: string, number, boolean and array of strings."));
         return false;
     }
     return true;

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

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplit = void 0;
+exports.validateDefinition = 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 validateSplit(log, maybeSplit, method, item) {
+function validateDefinition(log, maybeDefinition, method, item) {
     if (item === void 0) { item = 'feature flag name'; }
-    if (maybeSplit == undefined) { // eslint-disable-line eqeqeq
+    if (maybeDefinition == undefined) { // eslint-disable-line eqeqeq
         log.error(constants_1.ERROR_NULL, [method, item]);
     }
-    else if (!(0, lang_1.isString)(maybeSplit)) {
+    else if (!(0, lang_1.isString)(maybeDefinition)) {
         log.error(constants_1.ERROR_INVALID, [method, item]);
     }
     else {
-        if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
-            log.warn(constants_1.WARN_TRIMMING, [method, item, maybeSplit]);
-            maybeSplit = maybeSplit.trim();
+        if (TRIMMABLE_SPACES_REGEX.test(maybeDefinition)) {
+            log.warn(constants_1.WARN_TRIMMING, [method, item, maybeDefinition]);
+            maybeDefinition = maybeDefinition.trim();
         }
-        if (maybeSplit.length > 0) {
-            return maybeSplit;
+        if (maybeDefinition.length > 0) {
+            return maybeDefinition;
         }
         else {
             log.error(constants_1.ERROR_EMPTY, [method, item]);
@@ -27,4 +27,4 @@ function validateSplit(log, maybeSplit, method, item) {
     }
     return false;
 }
-exports.validateSplit = validateSplit;
+exports.validateDefinition = validateDefinition;

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

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplitExistence = void 0;
+exports.validateDefinitionExistence = 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 split 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 definition twice.
  */
-function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
+function validateDefinitionExistence(log, readinessManager, definitionName, labelOrDefinitionObj, 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 (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]);
+        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]);
             return false;
         }
     }
     return true;
 }
-exports.validateSplitExistence = validateSplitExistence;
+exports.validateDefinitionExistence = validateDefinitionExistence;

package/cjs/utils/inputValidation/definitions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDefinitions = void 0;
+var constants_1 = require("../../logger/constants");
+var lang_1 = require("../lang");
+var definition_1 = require("./definition");
+function validateDefinitions(log, maybeDefinitions, method, listName, item) {
+    if (listName === void 0) { listName = 'feature flag names'; }
+    if (item === void 0) { item = 'feature flag name'; }
+    if (Array.isArray(maybeDefinitions) && maybeDefinitions.length > 0) {
+        var validatedArray_1 = [];
+        // Remove invalid values
+        maybeDefinitions.forEach(function (maybeDefinition) {
+            var definitionName = (0, definition_1.validateDefinition)(log, maybeDefinition, method, item);
+            if (definitionName)
+                validatedArray_1.push(definitionName);
+        });
+        // Strip off duplicated values if we have valid definition 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.validateDefinitions = validateDefinitions;

package/cjs/utils/inputValidation/eventProperties.js

@@ -70,7 +70,7 @@ function validateEvaluationOptions(log, maybeOptions, method) {
         if (!impressionsDisabled)
             return options;
         // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-        return options ? (0, tslib_1.__assign)((0, tslib_1.__assign)({}, options), { impressionsDisabled: impressionsDisabled }) : { impressionsDisabled: impressionsDisabled };
+        return options ? tslib_1.__assign(tslib_1.__assign({}, options), { impressionsDisabled: impressionsDisabled }) : { impressionsDisabled: impressionsDisabled };
     }
     else if (maybeOptions) {
         log.error(constants_1.ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);

package/cjs/utils/inputValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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;
 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 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 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 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 splitExistence_1 = require("./splitExistence");
-Object.defineProperty(exports, "validateSplitExistence", { enumerable: true, get: function () { return splitExistence_1.validateSplitExistence; } });
+var definitionExistence_1 = require("./definitionExistence");
+Object.defineProperty(exports, "validateDefinitionExistence", { enumerable: true, get: function () { return definitionExistence_1.validateDefinitionExistence; } });
 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, featureFlagNameOrNames) {
+function validateIfReadyFromCache(log, readinessManager, method) {
     if (readinessManager.isReadyFromCache())
         return true;
-    log.warn(constants_1.CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag " + featureFlagNameOrNames.toString() : '']);
+    log.warn(constants_1.CLIENT_NOT_READY_FROM_CACHE, [method]);
     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, featureFlagNameOrNames) {
-    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+function validateIfOperational(log, readinessManager, method) {
+    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method);
 }
 exports.validateIfOperational = validateIfOperational;

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/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

@@ -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 };
+}