@featurevisor/sdk 0.36.0 → 0.38.0

package/lib/instance.js

@@ -2,7 +2,7 @@ import { createLogger } from "./logger";
 import { DatafileReader } from "./datafileReader";
 import { Emitter } from "./emitter";
 import { getBucketedNumber } from "./bucket";
-import { findForceFromFeature, getMatchedTrafficAndAllocation } from "./feature";
+import { findForceFromFeature, getMatchedTraffic, getMatchedTrafficAndAllocation } from "./feature";
 import { allConditionsAreMatched } from "./conditions";
 import { allGroupSegmentsAreMatched } from "./segments";
 var DEFAULT_BUCKET_KEY_SEPARATOR = ".";
@@ -16,6 +16,9 @@ var emptyDatafile = {
 export var EvaluationReason;
 (function (EvaluationReason) {
     EvaluationReason["NOT_FOUND"] = "not_found";
+    EvaluationReason["NO_VARIATIONS"] = "no_variations";
+    EvaluationReason["DISABLED"] = "disabled";
+    EvaluationReason["OUT_OF_RANGE"] = "out_of_range";
     EvaluationReason["FORCED"] = "forced";
     EvaluationReason["INITIAL"] = "initial";
     EvaluationReason["STICKY"] = "sticky";
@@ -68,7 +71,7 @@ var FeaturevisorInstance = /** @class */ (function () {
         this.datafileUrl = options.datafileUrl;
         this.handleDatafileFetch = options.handleDatafileFetch;
         this.initialFeatures = options.initialFeatures;
-        this.interceptAttributes = options.interceptAttributes;
+        this.interceptContext = options.interceptContext;
         this.logger = options.logger || createLogger();
         this.refreshInterval = options.refreshInterval;
         this.stickyFeatures = options.stickyFeatures;
@@ -148,7 +151,7 @@ var FeaturevisorInstance = /** @class */ (function () {
     /**
      * Bucketing
      */
-    FeaturevisorInstance.prototype.getBucketKey = function (feature, attributes) {
+    FeaturevisorInstance.prototype.getBucketKey = function (feature, context) {
         var featureKey = feature.key;
         var type;
         var attributeKeys;
@@ -170,7 +173,7 @@ var FeaturevisorInstance = /** @class */ (function () {
         }
         var bucketKey = [];
         attributeKeys.forEach(function (attributeKey) {
-            var attributeValue = attributes[attributeKey];
+            var attributeValue = context[attributeKey];
             if (typeof attributeValue === "undefined") {
                 return;
             }
@@ -187,15 +190,15 @@ var FeaturevisorInstance = /** @class */ (function () {
         bucketKey.push(featureKey);
         var result = bucketKey.join(this.bucketKeySeparator);
         if (this.configureBucketKey) {
-            return this.configureBucketKey(feature, attributes, result);
+            return this.configureBucketKey(feature, context, result);
         }
         return result;
     };
-    FeaturevisorInstance.prototype.getBucketValue = function (feature, attributes) {
-        var bucketKey = this.getBucketKey(feature, attributes);
+    FeaturevisorInstance.prototype.getBucketValue = function (feature, context) {
+        var bucketKey = this.getBucketKey(feature, context);
         var value = getBucketedNumber(bucketKey);
         if (this.configureBucketValue) {
-            return this.configureBucketValue(feature, attributes, value);
+            return this.configureBucketValue(feature, context, value);
         }
         return value;
     };
@@ -257,14 +260,166 @@ var FeaturevisorInstance = /** @class */ (function () {
         }
         clearInterval(this.intervalId);
     };
+    /**
+     * Flag
+     */
+    FeaturevisorInstance.prototype.evaluateFlag = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
+        var evaluation;
+        try {
+            var key = typeof featureKey === "string" ? featureKey : featureKey.key;
+            // sticky
+            if (this.stickyFeatures &&
+                this.stickyFeatures[key] &&
+                typeof this.stickyFeatures[key].enabled !== "undefined") {
+                evaluation = {
+                    featureKey: key,
+                    reason: EvaluationReason.STICKY,
+                    enabled: this.stickyFeatures[key].enabled,
+                    sticky: this.stickyFeatures[key],
+                };
+                this.logger.debug("using sticky enabled", evaluation);
+                return evaluation;
+            }
+            // initial
+            if (this.statuses &&
+                !this.statuses.ready &&
+                this.initialFeatures &&
+                this.initialFeatures[key] &&
+                typeof this.initialFeatures[key].enabled !== "undefined") {
+                evaluation = {
+                    featureKey: key,
+                    reason: EvaluationReason.INITIAL,
+                    enabled: this.initialFeatures[key].enabled,
+                    initial: this.initialFeatures[key],
+                };
+                this.logger.debug("using initial enabled", evaluation);
+                return evaluation;
+            }
+            var feature = this.getFeature(featureKey);
+            // not found
+            if (!feature) {
+                evaluation = {
+                    featureKey: key,
+                    reason: EvaluationReason.NOT_FOUND,
+                };
+                this.logger.warn("feature not found", evaluation);
+                return evaluation;
+            }
+            var finalContext = this.interceptContext ? this.interceptContext(context) : context;
+            // forced
+            var force = findForceFromFeature(feature, context, this.datafileReader);
+            if (force && typeof force.enabled !== "undefined") {
+                evaluation = {
+                    featureKey: feature.key,
+                    reason: EvaluationReason.FORCED,
+                    enabled: force.enabled,
+                };
+                this.logger.debug("forced enabled found", evaluation);
+                return evaluation;
+            }
+            // bucketing
+            var bucketValue_1 = this.getBucketValue(feature, finalContext);
+            var matchedTraffic = getMatchedTraffic(feature.traffic, finalContext, this.datafileReader);
+            if (matchedTraffic) {
+                // check if mutually exclusive
+                if (feature.ranges && feature.ranges.length > 0) {
+                    var matchedRange = feature.ranges.find(function (range) {
+                        return bucketValue_1 >= range[0] && bucketValue_1 < range[1];
+                    });
+                    // matched
+                    if (matchedRange) {
+                        evaluation = {
+                            featureKey: feature.key,
+                            reason: EvaluationReason.ALLOCATED,
+                            enabled: typeof matchedTraffic.enabled === "undefined" ? true : matchedTraffic.enabled,
+                            bucketValue: bucketValue_1,
+                        };
+                        return evaluation;
+                    }
+                    // no match
+                    evaluation = {
+                        featureKey: feature.key,
+                        reason: EvaluationReason.OUT_OF_RANGE,
+                        enabled: false,
+                        bucketValue: bucketValue_1,
+                    };
+                    this.logger.debug("not matched", evaluation);
+                    return evaluation;
+                }
+                // override from rule
+                if (typeof matchedTraffic.enabled !== "undefined") {
+                    evaluation = {
+                        featureKey: feature.key,
+                        reason: EvaluationReason.OVERRIDE,
+                        enabled: matchedTraffic.enabled,
+                        bucketValue: bucketValue_1,
+                        ruleKey: matchedTraffic.key,
+                        traffic: matchedTraffic,
+                    };
+                    this.logger.debug("override from rule", evaluation);
+                    return evaluation;
+                }
+                // treated as enabled because of matched traffic
+                if (bucketValue_1 < matchedTraffic.percentage) {
+                    // @TODO: verify if range check should be inclusive or not
+                    evaluation = {
+                        featureKey: feature.key,
+                        reason: EvaluationReason.RULE,
+                        enabled: true,
+                        bucketValue: bucketValue_1,
+                        ruleKey: matchedTraffic.key,
+                        traffic: matchedTraffic,
+                    };
+                    return evaluation;
+                }
+            }
+            // nothing matched
+            evaluation = {
+                featureKey: feature.key,
+                reason: EvaluationReason.ERROR,
+                enabled: false,
+                bucketValue: bucketValue_1,
+            };
+            return evaluation;
+        }
+        catch (e) {
+            evaluation = {
+                featureKey: typeof featureKey === "string" ? featureKey : featureKey.key,
+                reason: EvaluationReason.ERROR,
+                error: e,
+            };
+            return evaluation;
+        }
+    };
+    FeaturevisorInstance.prototype.isEnabled = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
+        try {
+            var evaluation = this.evaluateFlag(featureKey, context);
+            return evaluation.enabled === true;
+        }
+        catch (e) {
+            this.logger.error("isEnabled", { featureKey: featureKey, error: e });
+            return false;
+        }
+    };
     /**
      * Variation
      */
-    FeaturevisorInstance.prototype.evaluateVariation = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
+    FeaturevisorInstance.prototype.evaluateVariation = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
         var evaluation;
         try {
             var key = typeof featureKey === "string" ? featureKey : featureKey.key;
+            var flag = this.evaluateFlag(featureKey, context);
+            if (flag.enabled === false) {
+                evaluation = {
+                    featureKey: key,
+                    reason: EvaluationReason.DISABLED,
+                };
+                this.logger.debug("feature is disabled", evaluation);
+                return evaluation;
+            }
             // sticky
             if (this.stickyFeatures && this.stickyFeatures[key]) {
                 var variationValue = this.stickyFeatures[key].variation;
@@ -293,45 +448,52 @@ var FeaturevisorInstance = /** @class */ (function () {
                 this.logger.debug("using initial variation", evaluation);
                 return evaluation;
             }
-            var feature_1 = this.getFeature(featureKey);
+            var feature = this.getFeature(featureKey);
             // not found
-            if (!feature_1) {
+            if (!feature) {
                 evaluation = {
                     featureKey: key,
                     reason: EvaluationReason.NOT_FOUND,
                 };
-                this.logger.warn("feature not found in datafile", evaluation);
+                this.logger.warn("feature not found", evaluation);
+                return evaluation;
+            }
+            // no variations
+            if (!feature.variations || feature.variations.length === 0) {
+                evaluation = {
+                    featureKey: key,
+                    reason: EvaluationReason.NO_VARIATIONS,
+                };
+                this.logger.warn("no variations", evaluation);
                 return evaluation;
             }
-            var finalAttributes = this.interceptAttributes
-                ? this.interceptAttributes(attributes)
-                : attributes;
+            var finalContext = this.interceptContext ? this.interceptContext(context) : context;
             // forced
-            var force_1 = findForceFromFeature(feature_1, attributes, this.datafileReader);
+            var force_1 = findForceFromFeature(feature, context, this.datafileReader);
             if (force_1 && force_1.variation) {
-                var variation_1 = feature_1.variations.find(function (v) { return v.value === force_1.variation; });
-                if (variation_1) {
+                var variation = feature.variations.find(function (v) { return v.value === force_1.variation; });
+                if (variation) {
                     evaluation = {
-                        featureKey: feature_1.key,
+                        featureKey: feature.key,
                         reason: EvaluationReason.FORCED,
-                        variation: variation_1,
+                        variation: variation,
                     };
                     this.logger.debug("forced variation found", evaluation);
                     return evaluation;
                 }
             }
             // bucketing
-            var bucketValue = this.getBucketValue(feature_1, finalAttributes);
-            var _a = getMatchedTrafficAndAllocation(feature_1.traffic, finalAttributes, bucketValue, this.datafileReader, this.logger), matchedTraffic_1 = _a.matchedTraffic, matchedAllocation_1 = _a.matchedAllocation;
+            var bucketValue = this.getBucketValue(feature, finalContext);
+            var _a = getMatchedTrafficAndAllocation(feature.traffic, finalContext, bucketValue, this.datafileReader, this.logger), matchedTraffic_1 = _a.matchedTraffic, matchedAllocation_1 = _a.matchedAllocation;
             if (matchedTraffic_1) {
                 // override from rule
                 if (matchedTraffic_1.variation) {
-                    var variation_2 = feature_1.variations.find(function (v) { return v.value === matchedTraffic_1.variation; });
-                    if (variation_2) {
+                    var variation = feature.variations.find(function (v) { return v.value === matchedTraffic_1.variation; });
+                    if (variation) {
                         evaluation = {
-                            featureKey: feature_1.key,
+                            featureKey: feature.key,
                             reason: EvaluationReason.RULE,
-                            variation: variation_2,
+                            variation: variation,
                             bucketValue: bucketValue,
                             ruleKey: matchedTraffic_1.key,
                         };
@@ -341,38 +503,26 @@ var FeaturevisorInstance = /** @class */ (function () {
                 }
                 // regular allocation
                 if (matchedAllocation_1 && matchedAllocation_1.variation) {
-                    var variation_3 = feature_1.variations.find(function (v) { return v.value === matchedAllocation_1.variation; });
-                    if (variation_3) {
+                    var variation = feature.variations.find(function (v) { return v.value === matchedAllocation_1.variation; });
+                    if (variation) {
                         evaluation = {
-                            featureKey: feature_1.key,
+                            featureKey: feature.key,
                             reason: EvaluationReason.ALLOCATED,
                             bucketValue: bucketValue,
-                            variation: variation_3,
+                            variation: variation,
                         };
                         this.logger.debug("allocated variation", evaluation);
                         return evaluation;
                     }
                 }
             }
-            // fall back to default
-            var variation = feature_1.variations.find(function (v) { return v.value === feature_1.defaultVariation; });
-            if (variation) {
-                evaluation = {
-                    featureKey: feature_1.key,
-                    reason: EvaluationReason.DEFAULTED,
-                    bucketValue: bucketValue,
-                    variation: variation,
-                };
-                this.logger.debug("using default variation", evaluation);
-                return evaluation;
-            }
-            // nothing matched (this should never happen)
+            // nothing matched
             evaluation = {
-                featureKey: feature_1.key,
+                featureKey: feature.key,
                 reason: EvaluationReason.ERROR,
                 bucketValue: bucketValue,
             };
-            this.logger.error("no matched variation", evaluation);
+            this.logger.debug("no matched variation", evaluation);
             return evaluation;
         }
         catch (e) {
@@ -384,10 +534,10 @@ var FeaturevisorInstance = /** @class */ (function () {
             return evaluation;
         }
     };
-    FeaturevisorInstance.prototype.getVariation = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
+    FeaturevisorInstance.prototype.getVariation = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
         try {
-            var evaluation = this.evaluateVariation(featureKey, attributes);
+            var evaluation = this.evaluateVariation(featureKey, context);
             if (typeof evaluation.variationValue !== "undefined") {
                 return evaluation.variationValue;
             }
@@ -401,52 +551,30 @@ var FeaturevisorInstance = /** @class */ (function () {
             return undefined;
         }
     };
-    FeaturevisorInstance.prototype.getVariationBoolean = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.getVariation(featureKey, attributes);
-        return getValueByType(variationValue, "boolean");
-    };
-    FeaturevisorInstance.prototype.getVariationString = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.getVariation(featureKey, attributes);
-        return getValueByType(variationValue, "string");
-    };
-    FeaturevisorInstance.prototype.getVariationInteger = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.getVariation(featureKey, attributes);
-        return getValueByType(variationValue, "integer");
-    };
-    FeaturevisorInstance.prototype.getVariationDouble = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.getVariation(featureKey, attributes);
-        return getValueByType(variationValue, "double");
-    };
     /**
      * Activate
      */
-    FeaturevisorInstance.prototype.activate = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
+    FeaturevisorInstance.prototype.activate = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
         try {
-            var evaluation = this.evaluateVariation(featureKey, attributes);
+            var evaluation = this.evaluateVariation(featureKey, context);
             var variationValue = evaluation.variation
                 ? evaluation.variation.value
                 : evaluation.variationValue;
             if (typeof variationValue === "undefined") {
                 return undefined;
             }
-            var finalAttributes_1 = this.interceptAttributes
-                ? this.interceptAttributes(attributes)
-                : attributes;
-            var captureAttributes_1 = {};
+            var finalContext_1 = this.interceptContext ? this.interceptContext(context) : context;
+            var captureContext_1 = {};
             var attributesForCapturing = this.datafileReader
                 .getAllAttributes()
                 .filter(function (a) { return a.capture === true; });
             attributesForCapturing.forEach(function (a) {
-                if (typeof finalAttributes_1[a.key] !== "undefined") {
-                    captureAttributes_1[a.key] = attributes[a.key];
+                if (typeof finalContext_1[a.key] !== "undefined") {
+                    captureContext_1[a.key] = context[a.key];
                 }
             });
-            this.emitter.emit("activation", featureKey, variationValue, finalAttributes_1, captureAttributes_1, evaluation);
+            this.emitter.emit("activation", featureKey, variationValue, finalContext_1, captureContext_1, evaluation);
             return variationValue;
         }
         catch (e) {
@@ -454,64 +582,79 @@ var FeaturevisorInstance = /** @class */ (function () {
             return undefined;
         }
     };
-    FeaturevisorInstance.prototype.activateBoolean = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.activate(featureKey, attributes);
+    FeaturevisorInstance.prototype.activateBoolean = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
+        var variationValue = this.activate(featureKey, context);
         return getValueByType(variationValue, "boolean");
     };
-    FeaturevisorInstance.prototype.activateString = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.activate(featureKey, attributes);
+    FeaturevisorInstance.prototype.activateString = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
+        var variationValue = this.activate(featureKey, context);
         return getValueByType(variationValue, "string");
     };
-    FeaturevisorInstance.prototype.activateInteger = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.activate(featureKey, attributes);
+    FeaturevisorInstance.prototype.activateInteger = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
+        var variationValue = this.activate(featureKey, context);
         return getValueByType(variationValue, "integer");
     };
-    FeaturevisorInstance.prototype.activateDouble = function (featureKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variationValue = this.activate(featureKey, attributes);
+    FeaturevisorInstance.prototype.activateDouble = function (featureKey, context) {
+        if (context === void 0) { context = {}; }
+        var variationValue = this.activate(featureKey, context);
         return getValueByType(variationValue, "double");
     };
     /**
      * Variable
      */
-    FeaturevisorInstance.prototype.evaluateVariable = function (featureKey, variableKey, attributes) {
+    FeaturevisorInstance.prototype.evaluateVariable = function (featureKey, variableKey, context) {
         var _this = this;
-        if (attributes === void 0) { attributes = {}; }
+        if (context === void 0) { context = {}; }
         var evaluation;
         try {
             var key = typeof featureKey === "string" ? featureKey : featureKey.key;
+            var flag = this.evaluateFlag(featureKey, context);
+            if (flag.enabled === false) {
+                evaluation = {
+                    featureKey: key,
+                    reason: EvaluationReason.DISABLED,
+                };
+                this.logger.debug("feature is disabled", evaluation);
+                return evaluation;
+            }
             // sticky
-            if (this.stickyFeatures && this.stickyFeatures[key] && this.stickyFeatures[key].variables) {
-                var result = this.stickyFeatures[key].variables[variableKey];
-                if (typeof result !== "undefined") {
-                    evaluation = {
-                        featureKey: key,
-                        reason: EvaluationReason.STICKY,
-                        variableKey: variableKey,
-                        variableValue: result,
-                    };
-                    this.logger.debug("using sticky variable", evaluation);
-                    return evaluation;
+            if (this.stickyFeatures && this.stickyFeatures[key]) {
+                var variables = this.stickyFeatures[key].variables;
+                if (variables) {
+                    var result = variables[variableKey];
+                    if (typeof result !== "undefined") {
+                        evaluation = {
+                            featureKey: key,
+                            reason: EvaluationReason.STICKY,
+                            variableKey: variableKey,
+                            variableValue: result,
+                        };
+                        this.logger.debug("using sticky variable", evaluation);
+                        return evaluation;
+                    }
                 }
             }
             // initial
             if (this.statuses &&
                 !this.statuses.ready &&
                 this.initialFeatures &&
-                this.initialFeatures[key] &&
-                this.initialFeatures[key].variables &&
-                typeof this.initialFeatures[key].variables[variableKey] !== "undefined") {
-                evaluation = {
-                    featureKey: key,
-                    reason: EvaluationReason.INITIAL,
-                    variableKey: variableKey,
-                    variableValue: this.initialFeatures[key].variables[variableKey],
-                };
-                this.logger.debug("using initial variable", evaluation);
-                return evaluation;
+                this.initialFeatures[key]) {
+                var variables = this.initialFeatures[key].variables;
+                if (variables) {
+                    if (typeof variables[variableKey] !== "undefined") {
+                        evaluation = {
+                            featureKey: key,
+                            reason: EvaluationReason.INITIAL,
+                            variableKey: variableKey,
+                            variableValue: variables[variableKey],
+                        };
+                        this.logger.debug("using initial variable", evaluation);
+                        return evaluation;
+                    }
+                }
             }
             var feature = this.getFeature(featureKey);
             // not found
@@ -537,11 +680,9 @@ var FeaturevisorInstance = /** @class */ (function () {
                 this.logger.warn("variable schema not found", evaluation);
                 return evaluation;
             }
-            var finalAttributes_2 = this.interceptAttributes
-                ? this.interceptAttributes(attributes)
-                : attributes;
+            var finalContext_2 = this.interceptContext ? this.interceptContext(context) : context;
             // forced
-            var force = findForceFromFeature(feature, attributes, this.datafileReader);
+            var force = findForceFromFeature(feature, context, this.datafileReader);
             if (force && force.variables && typeof force.variables[variableKey] !== "undefined") {
                 evaluation = {
                     featureKey: feature.key,
@@ -554,8 +695,8 @@ var FeaturevisorInstance = /** @class */ (function () {
                 return evaluation;
             }
             // bucketing
-            var bucketValue = this.getBucketValue(feature, finalAttributes_2);
-            var _a = getMatchedTrafficAndAllocation(feature.traffic, finalAttributes_2, bucketValue, this.datafileReader, this.logger), matchedTraffic = _a.matchedTraffic, matchedAllocation_2 = _a.matchedAllocation;
+            var bucketValue = this.getBucketValue(feature, finalContext_2);
+            var _a = getMatchedTrafficAndAllocation(feature.traffic, finalContext_2, bucketValue, this.datafileReader, this.logger), matchedTraffic = _a.matchedTraffic, matchedAllocation_2 = _a.matchedAllocation;
             if (matchedTraffic) {
                 // override from rule
                 if (matchedTraffic.variables &&
@@ -573,7 +714,7 @@ var FeaturevisorInstance = /** @class */ (function () {
                     return evaluation;
                 }
                 // regular allocation
-                if (matchedAllocation_2 && matchedAllocation_2.variation) {
+                if (matchedAllocation_2 && matchedAllocation_2.variation && Array.isArray(feature.variations)) {
                     var variation = feature.variations.find(function (v) { return v.value === matchedAllocation_2.variation; });
                     if (variation && variation.variables) {
                         var variableFromVariation = variation.variables.find(function (v) { return v.key === variableKey; });
@@ -581,12 +722,12 @@ var FeaturevisorInstance = /** @class */ (function () {
                             if (variableFromVariation.overrides) {
                                 var override = variableFromVariation.overrides.find(function (o) {
                                     if (o.conditions) {
-                                        return allConditionsAreMatched(typeof o.conditions === "string" ? JSON.parse(o.conditions) : o.conditions, finalAttributes_2);
+                                        return allConditionsAreMatched(typeof o.conditions === "string" ? JSON.parse(o.conditions) : o.conditions, finalContext_2);
                                     }
                                     if (o.segments) {
                                         return allGroupSegmentsAreMatched(typeof o.segments === "string" && o.segments !== "*"
                                             ? JSON.parse(o.segments)
-                                            : o.segments, finalAttributes_2, _this.datafileReader);
+                                            : o.segments, finalContext_2, _this.datafileReader);
                                     }
                                     return false;
                                 });
@@ -643,10 +784,10 @@ var FeaturevisorInstance = /** @class */ (function () {
             return evaluation;
         }
     };
-    FeaturevisorInstance.prototype.getVariable = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
+    FeaturevisorInstance.prototype.getVariable = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
         try {
-            var evaluation = this.evaluateVariable(featureKey, variableKey, attributes);
+            var evaluation = this.evaluateVariable(featureKey, variableKey, context);
             if (typeof evaluation.variableValue !== "undefined") {
                 if (evaluation.variableSchema &&
                     evaluation.variableSchema.type === "json" &&
@@ -662,39 +803,39 @@ var FeaturevisorInstance = /** @class */ (function () {
             return undefined;
         }
     };
-    FeaturevisorInstance.prototype.getVariableBoolean = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, attributes);
+    FeaturevisorInstance.prototype.getVariableBoolean = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
+        var variableValue = this.getVariable(featureKey, variableKey, context);
         return getValueByType(variableValue, "boolean");
     };
-    FeaturevisorInstance.prototype.getVariableString = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, attributes);
+    FeaturevisorInstance.prototype.getVariableString = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
+        var variableValue = this.getVariable(featureKey, variableKey, context);
         return getValueByType(variableValue, "string");
     };
-    FeaturevisorInstance.prototype.getVariableInteger = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, attributes);
+    FeaturevisorInstance.prototype.getVariableInteger = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
+        var variableValue = this.getVariable(featureKey, variableKey, context);
         return getValueByType(variableValue, "integer");
     };
-    FeaturevisorInstance.prototype.getVariableDouble = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, attributes);
+    FeaturevisorInstance.prototype.getVariableDouble = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
+        var variableValue = this.getVariable(featureKey, variableKey, context);
         return getValueByType(variableValue, "double");
     };
-    FeaturevisorInstance.prototype.getVariableArray = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, attributes);
+    FeaturevisorInstance.prototype.getVariableArray = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
+        var variableValue = this.getVariable(featureKey, variableKey, context);
         return getValueByType(variableValue, "array");
     };
-    FeaturevisorInstance.prototype.getVariableObject = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, attributes);
+    FeaturevisorInstance.prototype.getVariableObject = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
+        var variableValue = this.getVariable(featureKey, variableKey, context);
         return getValueByType(variableValue, "object");
     };
-    FeaturevisorInstance.prototype.getVariableJSON = function (featureKey, variableKey, attributes) {
-        if (attributes === void 0) { attributes = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, attributes);
+    FeaturevisorInstance.prototype.getVariableJSON = function (featureKey, variableKey, context) {
+        if (context === void 0) { context = {}; }
+        var variableValue = this.getVariable(featureKey, variableKey, context);
         return getValueByType(variableValue, "json");
     };
     return FeaturevisorInstance;