@splitsoftware/splitio-commons 3.1.1-rc.0 → 3.1.1-rc.2

package/CHANGES.txt

@@ -1,4 +1,4 @@
-3.2.0 (July 31, 2026)
+3.2.0 (August 10, 2026)
  - Added support for AI configs.
  - Removed Configs SDK-related types and modules and moved them to the Configs SDK repository.
 

package/cjs/evaluator/condition/index.js

@@ -23,7 +23,7 @@ function conditionContext(log, matcherEvaluator, treatments, label, conditionTyp
         // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
         if (conditionType === 'ROLLOUT' && !(0, engineUtils_1.shouldApplyRollout)(trafficAllocation, key.bucketingKey, trafficAllocationSeed)) {
             return {
-                treatment: undefined,
+                // treatment value is assigned later, at Engine's evaluationResult
                 label: labels_1.NOT_IN_SPLIT
             };
         }

package/cjs/evaluator/index.js

@@ -7,6 +7,7 @@ var labels_1 = require("../utils/labels");
 var constants_1 = require("../utils/constants");
 var sets_1 = require("../utils/lang/sets");
 var constants_2 = require("../logger/constants");
+var objectAssign_1 = require("../utils/lang/objectAssign");
 var EVALUATION_EXCEPTION = {
     treatment: constants_1.CONTROL,
     label: labels_1.EXCEPTION,
@@ -24,7 +25,13 @@ function treatmentsException(definitionNames) {
     });
     return evaluations;
 }
-function evaluateFeature(log, key, definitionName, attributes, storage, options) {
+function setEvaluationDataFromDefinition(evaluation, definition) {
+    return (0, objectAssign_1.objectAssign)(evaluation, {
+        definition: definition,
+        config: definition.configurations && definition.configurations[evaluation.treatment] || null
+    });
+}
+function evaluateFeature(log, key, definitionName, attributes, storage) {
     var definition;
     try {
         definition = storage.definitions.get(definitionName);
@@ -34,15 +41,15 @@ function evaluateFeature(log, key, definitionName, attributes, storage, options)
         return EVALUATION_EXCEPTION;
     }
     return (0, thenable_1.thenable)(definition) ?
-        definition.then(function (definition) { return getEvaluation(log, key, definition, attributes, storage, options); })
+        definition.then(function (definition) { return getEvaluation(log, key, definition, 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 EVALUATION_EXCEPTION; }) :
-        getEvaluation(log, key, definition, attributes, storage, options);
+        getEvaluation(log, key, definition, attributes, storage);
 }
 exports.evaluateFeature = evaluateFeature;
-function evaluateFeatures(log, key, definitionNames, attributes, storage, options) {
+function evaluateFeatures(log, key, definitionNames, attributes, storage) {
     var definitions;
     try {
         definitions = storage.definitions.getMany(definitionNames);
@@ -52,15 +59,15 @@ function evaluateFeatures(log, key, definitionNames, attributes, storage, option
         return treatmentsException(definitionNames);
     }
     return (0, thenable_1.thenable)(definitions) ?
-        definitions.then(function (definitions) { return getEvaluations(log, key, definitionNames, definitions, attributes, storage, options); })
+        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, options);
+        getEvaluations(log, key, definitionNames, definitions, attributes, storage);
 }
 exports.evaluateFeatures = evaluateFeatures;
-function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method, options) {
+function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method) {
     var storedFlagNames;
     function evaluate(featureFlagsByFlagSets) {
         var featureFlags = new Set();
@@ -74,7 +81,7 @@ function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, met
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, (0, sets_1.setToArray)(featureFlags), attributes, storage, options) :
+            evaluateFeatures(log, key, (0, sets_1.setToArray)(featureFlags), attributes, storage) :
             {};
     }
     // get features by flag sets
@@ -92,30 +99,21 @@ function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, met
         evaluate(storedFlagNames);
 }
 exports.evaluateFeaturesByFlagSets = evaluateFeaturesByFlagSets;
-function setEvaluationDataFromDefinition(evaluation, definition, options) {
-    evaluation.changeNumber = definition.changeNumber;
-    evaluation.config = definition.configurations && definition.configurations[evaluation.treatment] || null;
-    evaluation.type = definition.type;
-    evaluation.subtype = definition.subtype;
-    // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-    evaluation.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || definition.impressionsDisabled;
-    return evaluation;
-}
-function getEvaluation(log, key, definition, attributes, storage, options) {
+function getEvaluation(log, key, definition, attributes, storage) {
     if (definition) {
         var split = (0, Engine_1.engineParser)(log, definition, storage);
         var evaluation = split.getTreatment(key, attributes, evaluateFeature);
         return (0, thenable_1.thenable)(evaluation) ?
-            evaluation.then(function (result) { return setEvaluationDataFromDefinition(result, definition, options); }) :
-            setEvaluationDataFromDefinition(evaluation, definition, options);
+            evaluation.then(function (result) { return setEvaluationDataFromDefinition(result, definition); }) :
+            setEvaluationDataFromDefinition(evaluation, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;
 }
-function getEvaluations(log, key, definitionNames, definitions, attributes, storage, options) {
+function getEvaluations(log, key, definitionNames, definitions, attributes, storage) {
     var result = {};
     var thenables = [];
     definitionNames.forEach(function (definitionName) {
-        var evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage, options);
+        var evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage);
         (0, thenable_1.thenable)(evaluation) ?
             thenables.push(evaluation.then(function (res) {
                 result[definitionName] = res;
@@ -141,7 +139,7 @@ function getDefaultTreatment(definition) {
     if (definition) {
         return setEvaluationDataFromDefinition({
             treatment: definition.defaultTreatment,
-            label: labels_1.NO_CONDITION_MATCH // "default rule"
+            label: labels_1.NO_CONDITION_MATCH, // "default rule"
         }, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;

package/cjs/sdkClient/client.js

@@ -18,10 +18,10 @@ function treatmentsNotReady(featureFlagNames) {
     });
     return evaluations;
 }
-function stringify(options) {
-    if (options && options.properties) {
+function stringify(properties) {
+    if (properties) {
         try {
-            return JSON.stringify(options.properties);
+            return JSON.stringify(properties);
         }
         catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
     }
@@ -40,13 +40,13 @@ function clientFactory(params) {
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? constants_1.TREATMENT_WITH_CONFIG : constants_1.TREATMENT);
         var wrapUp = function (evaluationResult) {
             var queue = [];
-            var treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
+            var treatment = processEvaluation(evaluationResult, featureFlagName, key, withConfig, methodName, queue, options);
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatment;
         };
         var evaluation = readinessManager.isReadyFromCache() ?
-            (0, evaluator_1.evaluateFeature)(log, key, featureFlagName, attributes, storage, options) :
+            (0, evaluator_1.evaluateFeature)(log, key, featureFlagName, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentNotReady) :
                 treatmentNotReady;
@@ -62,16 +62,15 @@ function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            (0, evaluator_1.evaluateFeatures)(log, key, featureFlagNames, attributes, storage, options) :
+            (0, evaluator_1.evaluateFeatures)(log, key, featureFlagNames, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentsNotReady(featureFlagNames)) :
                 treatmentsNotReady(featureFlagNames);
@@ -88,16 +87,15 @@ function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            (0, evaluator_1.evaluateFeaturesByFlagSets)(log, key, flagSetNames, attributes, storage, methodName, options) :
+            (0, evaluator_1.evaluateFeaturesByFlagSets)(log, key, flagSetNames, attributes, storage, methodName) :
             isAsync ?
                 Promise.resolve({}) :
                 {};
@@ -113,10 +111,11 @@ function clientFactory(params) {
         return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, true, constants_1.TREATMENTS_WITH_CONFIG_BY_FLAGSET, constants_1.GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
     }
     // Internal function
-    function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
+    function processEvaluation(evaluation, featureFlagName, key, withConfig, invokingMethodName, queue, options) {
+        if (options === void 0) { options = {}; }
         var matchingKey = (0, key_1.getMatching)(key);
         var bucketingKey = (0, key_1.getBucketing)(key);
-        var changeNumber = evaluation.changeNumber, impressionsDisabled = evaluation.impressionsDisabled;
+        var definition = evaluation.definition;
         var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
         if (treatment === constants_1.CONTROL) {
             var fallbackTreatment = fallbackCalculator(featureFlagName, label);
@@ -134,10 +133,10 @@ function clientFactory(params) {
                     time: Date.now(),
                     bucketingKey: bucketingKey,
                     label: label,
-                    changeNumber: changeNumber,
-                    properties: properties
+                    changeNumber: definition.changeNumber,
+                    properties: stringify(options.properties)
                 },
-                disabled: impressionsDisabled
+                disabled: options.impressionsDisabled || definition.impressionsDisabled
             });
         }
         if (withConfig) {

package/esm/evaluator/condition/index.js

@@ -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: undefined,
+                // treatment value is assigned later, at Engine's evaluationResult
                 label: NOT_IN_SPLIT
             };
         }

package/esm/evaluator/index.js

@@ -4,6 +4,7 @@ import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_NOT_FOUND } from '../utils/la
 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 = {
     treatment: CONTROL,
     label: EXCEPTION,
@@ -21,7 +22,13 @@ function treatmentsException(definitionNames) {
     });
     return evaluations;
 }
-export function evaluateFeature(log, key, definitionName, attributes, storage, options) {
+function setEvaluationDataFromDefinition(evaluation, definition) {
+    return objectAssign(evaluation, {
+        definition: definition,
+        config: definition.configurations && definition.configurations[evaluation.treatment] || null
+    });
+}
+export function evaluateFeature(log, key, definitionName, attributes, storage) {
     var definition;
     try {
         definition = storage.definitions.get(definitionName);
@@ -31,14 +38,14 @@ export function evaluateFeature(log, key, definitionName, attributes, storage, o
         return EVALUATION_EXCEPTION;
     }
     return thenable(definition) ?
-        definition.then(function (definition) { return getEvaluation(log, key, definition, attributes, storage, options); })
+        definition.then(function (definition) { return getEvaluation(log, key, definition, 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 EVALUATION_EXCEPTION; }) :
-        getEvaluation(log, key, definition, attributes, storage, options);
+        getEvaluation(log, key, definition, attributes, storage);
 }
-export function evaluateFeatures(log, key, definitionNames, attributes, storage, options) {
+export function evaluateFeatures(log, key, definitionNames, attributes, storage) {
     var definitions;
     try {
         definitions = storage.definitions.getMany(definitionNames);
@@ -48,14 +55,14 @@ export function evaluateFeatures(log, key, definitionNames, attributes, storage,
         return treatmentsException(definitionNames);
     }
     return thenable(definitions) ?
-        definitions.then(function (definitions) { return getEvaluations(log, key, definitionNames, definitions, attributes, storage, options); })
+        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, options);
+        getEvaluations(log, key, definitionNames, definitions, attributes, storage);
 }
-export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method, options) {
+export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method) {
     var storedFlagNames;
     function evaluate(featureFlagsByFlagSets) {
         var featureFlags = new Set();
@@ -69,7 +76,7 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage, options) :
+            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
             {};
     }
     // get features by flag sets
@@ -86,30 +93,21 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
             .catch(function () { return ({}); }) :
         evaluate(storedFlagNames);
 }
-function setEvaluationDataFromDefinition(evaluation, definition, options) {
-    evaluation.changeNumber = definition.changeNumber;
-    evaluation.config = definition.configurations && definition.configurations[evaluation.treatment] || null;
-    evaluation.type = definition.type;
-    evaluation.subtype = definition.subtype;
-    // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-    evaluation.impressionsDisabled = (options === null || options === void 0 ? void 0 : options.impressionsDisabled) || definition.impressionsDisabled;
-    return evaluation;
-}
-function getEvaluation(log, key, definition, attributes, storage, options) {
+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 setEvaluationDataFromDefinition(result, definition, options); }) :
-            setEvaluationDataFromDefinition(evaluation, definition, options);
+            evaluation.then(function (result) { return setEvaluationDataFromDefinition(result, definition); }) :
+            setEvaluationDataFromDefinition(evaluation, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;
 }
-function getEvaluations(log, key, definitionNames, definitions, attributes, storage, options) {
+function getEvaluations(log, key, definitionNames, definitions, attributes, storage) {
     var result = {};
     var thenables = [];
     definitionNames.forEach(function (definitionName) {
-        var evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage, options);
+        var evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage);
         thenable(evaluation) ?
             thenables.push(evaluation.then(function (res) {
                 result[definitionName] = res;
@@ -134,7 +132,7 @@ function getDefaultTreatment(definition) {
     if (definition) {
         return setEvaluationDataFromDefinition({
             treatment: definition.defaultTreatment,
-            label: NO_CONDITION_MATCH // "default rule"
+            label: NO_CONDITION_MATCH, // "default rule"
         }, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;

package/esm/sdkClient/client.js

@@ -15,10 +15,10 @@ function treatmentsNotReady(featureFlagNames) {
     });
     return evaluations;
 }
-export function stringify(options) {
-    if (options && options.properties) {
+export function stringify(properties) {
+    if (properties) {
         try {
-            return JSON.stringify(options.properties);
+            return JSON.stringify(properties);
         }
         catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
     }
@@ -36,13 +36,13 @@ export function clientFactory(params) {
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
         var wrapUp = function (evaluationResult) {
             var queue = [];
-            var treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
+            var treatment = processEvaluation(evaluationResult, featureFlagName, key, withConfig, methodName, queue, options);
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatment;
         };
         var evaluation = readinessManager.isReadyFromCache() ?
-            evaluateFeature(log, key, featureFlagName, attributes, storage, options) :
+            evaluateFeature(log, key, featureFlagName, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentNotReady) :
                 treatmentNotReady;
@@ -58,16 +58,15 @@ export function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            evaluateFeatures(log, key, featureFlagNames, attributes, storage, options) :
+            evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentsNotReady(featureFlagNames)) :
                 treatmentsNotReady(featureFlagNames);
@@ -84,16 +83,15 @@ export function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
         var evaluations = readinessManager.isReadyFromCache() ?
-            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName, options) :
+            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
             isAsync ?
                 Promise.resolve({}) :
                 {};
@@ -109,10 +107,11 @@ export function clientFactory(params) {
         return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
     }
     // Internal function
-    function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
+    function processEvaluation(evaluation, featureFlagName, key, withConfig, invokingMethodName, queue, options) {
+        if (options === void 0) { options = {}; }
         var matchingKey = getMatching(key);
         var bucketingKey = getBucketing(key);
-        var changeNumber = evaluation.changeNumber, impressionsDisabled = evaluation.impressionsDisabled;
+        var definition = evaluation.definition;
         var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
         if (treatment === CONTROL) {
             var fallbackTreatment = fallbackCalculator(featureFlagName, label);
@@ -130,10 +129,10 @@ export function clientFactory(params) {
                     time: Date.now(),
                     bucketingKey: bucketingKey,
                     label: label,
-                    changeNumber: changeNumber,
-                    properties: properties
+                    changeNumber: definition.changeNumber,
+                    properties: stringify(options.properties)
                 },
-                disabled: impressionsDisabled
+                disabled: options.impressionsDisabled || definition.impressionsDisabled
             });
         }
         if (withConfig) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.0",
+  "version": "3.1.1-rc.2",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/Engine.ts

@@ -7,12 +7,12 @@ import { CONTROL } from '../utils/constants';
 import { IDefinition, MaybeThenable } from '../dtos/types';
 import SplitIO from '../../types/splitio';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluation, IEvaluationResult, IDefinitionEvaluator } from './types';
+import { IEvaluation, IDefinitionEvaluator } from './types';
 import { ILogger } from '../logger/types';
 import { ENGINE_DEFAULT } from '../logger/constants';
 import { prerequisitesMatcherContext } from './matchers/prerequisites';
 
-function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
+function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluation {
   return {
     treatment: get(result, 'treatment', defaultTreatment),
     label: get(result, 'label', NO_CONDITION_MATCH)
@@ -29,7 +29,7 @@ export function engineParser(log: ILogger, split: IDefinition, storage: IStorage
 
   return {
 
-    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: IDefinitionEvaluator): MaybeThenable<IEvaluationResult> {
+    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: IDefinitionEvaluator): MaybeThenable<IEvaluation> {
 
       const parsedKey = keyParser(key);
 

package/src/evaluator/condition/index.ts

@@ -29,9 +29,9 @@ export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.S
     // 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: undefined, // treatment value is assigned later
+        // treatment value is assigned later, at Engine's evaluationResult
         label: NOT_IN_SPLIT
-      };
+      } as IEvaluation;
     }
 
     // matcherEvaluator could be Async, this relays on matchers return value, so we need

package/src/evaluator/index.ts

@@ -4,11 +4,12 @@ import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_NOT_FOUND } from '../utils/la
 import { CONTROL } from '../utils/constants';
 import { IDefinition, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluationResult } from './types';
+import { IEvaluation } from './types';
 import SplitIO from '../../types/splitio';
 import { ILogger } from '../logger/types';
 import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 const EVALUATION_EXCEPTION = {
   treatment: CONTROL,
@@ -23,21 +24,27 @@ const EVALUATION_DEFINITION_NOT_FOUND = {
 };
 
 function treatmentsException(definitionNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
+  const evaluations: Record<string, IEvaluation> = {};
   definitionNames.forEach(definitionName => {
     evaluations[definitionName] = EVALUATION_EXCEPTION;
   });
   return evaluations;
 }
 
+function setEvaluationDataFromDefinition(evaluation: IEvaluation, definition: IDefinition): IEvaluation {
+  return objectAssign(evaluation, {
+    definition,
+    config: definition.configurations && definition.configurations[evaluation.treatment] || null
+  });
+}
+
 export function evaluateFeature(
   log: ILogger,
   key: SplitIO.SplitKey,
   definitionName: string,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   let definition;
 
   try {
@@ -48,13 +55,13 @@ export function evaluateFeature(
   }
 
   return thenable(definition) ?
-    definition.then((definition) => getEvaluation(log, key, definition, attributes, storage, options))
+    definition.then((definition) => getEvaluation(log, key, definition, 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
         () => EVALUATION_EXCEPTION
       ) :
-    getEvaluation(log, key, definition, attributes, storage, options);
+    getEvaluation(log, key, definition, attributes, storage);
 }
 
 export function evaluateFeatures(
@@ -63,8 +70,7 @@ export function evaluateFeatures(
   definitionNames: string[],
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
+): MaybeThenable<Record<string, IEvaluation>> {
   let definitions;
 
   try {
@@ -75,13 +81,13 @@ export function evaluateFeatures(
   }
 
   return thenable(definitions) ?
-    definitions.then(definitions => getEvaluations(log, key, definitionNames, definitions, attributes, storage, options))
+    definitions.then(definitions => 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
         () => treatmentsException(definitionNames)
       ) :
-    getEvaluations(log, key, definitionNames, definitions, attributes, storage, options);
+    getEvaluations(log, key, definitionNames, definitions, attributes, storage);
 }
 
 export function evaluateFeaturesByFlagSets(
@@ -91,8 +97,7 @@ export function evaluateFeaturesByFlagSets(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   method: string,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
+): MaybeThenable<Record<string, IEvaluation>> {
   let storedFlagNames: MaybeThenable<Set<string>[]>;
 
   function evaluate(featureFlagsByFlagSets: Set<string>[]) {
@@ -107,7 +112,7 @@ export function evaluateFeaturesByFlagSets(
     }
 
     return featureFlags.size ?
-      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage, options) :
+      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
       {};
   }
 
@@ -126,33 +131,21 @@ export function evaluateFeaturesByFlagSets(
     evaluate(storedFlagNames);
 }
 
-function setEvaluationDataFromDefinition(evaluation: IEvaluationResult, definition: IDefinition, options?: SplitIO.EvaluationOptions): IEvaluationResult {
-  evaluation.changeNumber = definition.changeNumber;
-  evaluation.config = definition.configurations && definition.configurations[evaluation.treatment] || null;
-  evaluation.type = definition.type;
-  evaluation.subtype = definition.subtype;
-  // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-  evaluation.impressionsDisabled = options?.impressionsDisabled || definition.impressionsDisabled;
-
-  return evaluation;
-}
-
 function getEvaluation(
   log: ILogger,
   key: SplitIO.SplitKey,
   definition: IDefinition | null,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
 
   if (definition) {
     const split = engineParser(log, definition, storage);
     const evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
     return thenable(evaluation) ?
-      evaluation.then(result => setEvaluationDataFromDefinition(result, definition, options)) :
-      setEvaluationDataFromDefinition(evaluation, definition, options);
+      evaluation.then(result => setEvaluationDataFromDefinition(result, definition)) :
+      setEvaluationDataFromDefinition(evaluation, definition);
   }
 
   return EVALUATION_DEFINITION_NOT_FOUND;
@@ -165,12 +158,11 @@ function getEvaluations(
   definitions: Record<string, IDefinition | null>,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
-  options?: SplitIO.EvaluationOptions,
-): MaybeThenable<Record<string, IEvaluationResult>> {
-  const result: Record<string, IEvaluationResult> = {};
+): MaybeThenable<Record<string, IEvaluation>> {
+  const result: Record<string, IEvaluation> = {};
   const thenables: Promise<void>[] = [];
   definitionNames.forEach(definitionName => {
-    const evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage, options);
+    const evaluation = getEvaluation(log, key, definitions[definitionName], attributes, storage);
     thenable(evaluation) ?
       thenables.push(evaluation.then(res => {
         result[definitionName] = res;
@@ -184,7 +176,7 @@ function getEvaluations(
 export function evaluateDefaultTreatment(
   definitionName: string,
   storage: IStorageSync | IStorageAsync,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   let definition;
 
   try {
@@ -200,11 +192,11 @@ export function evaluateDefaultTreatment(
 
 function getDefaultTreatment(
   definition: IDefinition | null,
-): MaybeThenable<IEvaluationResult> {
+): MaybeThenable<IEvaluation> {
   if (definition) {
     return setEvaluationDataFromDefinition({
       treatment: definition.defaultTreatment,
-      label: NO_CONDITION_MATCH // "default rule"
+      label: NO_CONDITION_MATCH, // "default rule"
     }, definition);
   }
 

package/src/evaluator/types.ts

@@ -19,16 +19,12 @@ export interface IMatcherDto {
 }
 
 export interface IEvaluation {
-  treatment?: string,
+  treatment: string,
   label: string,
-  changeNumber?: number,
+  definition?: IDefinition
   config?: string | null | SplitIO.JsonObject
-  type?: IDefinition['type']
-  subtype?: IDefinition['subtype']
 }
 
-export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }
-
 export type IDefinitionEvaluator = (log: ILogger, key: SplitIO.SplitKey, definitionName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
 export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>

package/src/sdkClient/client.ts

@@ -4,7 +4,7 @@ import { getMatching, getBucketing } from '../utils/key';
 import { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS } from '../utils/constants';
-import { IEvaluationResult } from '../evaluator/types';
+import { IEvaluation } from '../evaluator/types';
 import SplitIO from '../../types/splitio';
 import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
@@ -16,17 +16,17 @@ import { trackMethodFactory } from './trackMethod';
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
 function treatmentsNotReady(featureFlagNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
+  const evaluations: Record<string, IEvaluation> = {};
   featureFlagNames.forEach(featureFlagName => {
     evaluations[featureFlagName] = treatmentNotReady;
   });
   return evaluations;
 }
 
-export function stringify(options?: SplitIO.EvaluationOptions) {
-  if (options && options.properties) {
+export function stringify(properties?: SplitIO.Properties) {
+  if (properties) {
     try {
-      return JSON.stringify(options.properties);
+      return JSON.stringify(properties);
     } catch { /* JSON.stringify should never throw with validated options, but handling just in case */ }
   }
 }
@@ -42,9 +42,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENT) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
-    const wrapUp = (evaluationResult: IEvaluationResult) => {
+    const wrapUp = (evaluationResult: IEvaluation) => {
       const queue: ImpressionDecorated[] = [];
-      const treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
+      const treatment = processEvaluation(evaluationResult, featureFlagName, key, withConfig, methodName, queue, options);
       impressionsTracker.track(queue, attributes);
 
       stopTelemetryTracker(queue[0] && queue[0].imp.label);
@@ -52,7 +52,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluation = readinessManager.isReadyFromCache() ?
-      evaluateFeature(log, key, featureFlagName, attributes, storage, options) :
+      evaluateFeature(log, key, featureFlagName, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentNotReady) :
         treatmentNotReady;
@@ -67,12 +67,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENTS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluation>) => {
       const queue: ImpressionDecorated[] = [];
       const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
       Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -81,7 +80,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReadyFromCache() ?
-      evaluateFeatures(log, key, featureFlagNames, attributes, storage, options) :
+      evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentsNotReady(featureFlagNames)) :
         treatmentsNotReady(featureFlagNames);
@@ -96,12 +95,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS, methodName = GET_TREATMENTS_BY_FLAG_SETS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(method);
 
-    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluation>) => {
       const queue: ImpressionDecorated[] = [];
       const treatments: SplitIO.Treatments | SplitIO.TreatmentsWithConfig = {};
-      const properties = stringify(options);
       Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, withConfig, methodName, queue, options);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -110,7 +108,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName, options) :
+      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
       isAsync ?
         Promise.resolve({}) :
         {};
@@ -132,18 +130,18 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
   // Internal function
   function processEvaluation(
-    evaluation: IEvaluationResult,
+    evaluation: IEvaluation,
     featureFlagName: string,
     key: SplitIO.SplitKey,
-    properties: string | undefined,
     withConfig: boolean,
     invokingMethodName: string,
-    queue: ImpressionDecorated[]
+    queue: ImpressionDecorated[],
+    options: SplitIO.EvaluationOptions = {}
   ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    const { changeNumber, impressionsDisabled } = evaluation;
+    const { definition } = evaluation;
     let { treatment, label, config = null } = evaluation;
 
     if (treatment === CONTROL) {
@@ -163,10 +161,10 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
           time: Date.now(),
           bucketingKey,
           label,
-          changeNumber: changeNumber as number,
-          properties
-        },
-        disabled: impressionsDisabled
+          changeNumber: definition!.changeNumber,
+          properties: stringify(options.properties)
+        }, // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
+        disabled: options.impressionsDisabled || definition!.impressionsDisabled
       });
     }