@featurevisor/sdk 1.20.0 → 1.27.2

package/lib/instance.js

@@ -1,926 +0,0 @@
-import { createLogger } from "./logger";
-import { DatafileReader } from "./datafileReader";
-import { Emitter } from "./emitter";
-import { getBucketedNumber } from "./bucket";
-import { findForceFromFeature, getMatchedTraffic, getMatchedTrafficAndAllocation, parseFromStringifiedSegments, } from "./feature";
-import { allConditionsAreMatched } from "./conditions";
-import { allGroupSegmentsAreMatched } from "./segments";
-var DEFAULT_BUCKET_KEY_SEPARATOR = ".";
-var emptyDatafile = {
-    schemaVersion: "1",
-    revision: "unknown",
-    attributes: [],
-    segments: [],
-    features: [],
-};
-export var EvaluationReason;
-(function (EvaluationReason) {
-    EvaluationReason["NOT_FOUND"] = "not_found";
-    EvaluationReason["NO_VARIATIONS"] = "no_variations";
-    EvaluationReason["NO_MATCH"] = "no_match";
-    EvaluationReason["DISABLED"] = "disabled";
-    EvaluationReason["REQUIRED"] = "required";
-    EvaluationReason["OUT_OF_RANGE"] = "out_of_range";
-    EvaluationReason["FORCED"] = "forced";
-    EvaluationReason["INITIAL"] = "initial";
-    EvaluationReason["STICKY"] = "sticky";
-    EvaluationReason["RULE"] = "rule";
-    EvaluationReason["ALLOCATED"] = "allocated";
-    EvaluationReason["DEFAULTED"] = "defaulted";
-    EvaluationReason["OVERRIDE"] = "override";
-    EvaluationReason["ERROR"] = "error";
-})(EvaluationReason || (EvaluationReason = {}));
-function fetchDatafileContent(datafileUrl, handleDatafileFetch) {
-    if (handleDatafileFetch) {
-        return handleDatafileFetch(datafileUrl);
-    }
-    return fetch(datafileUrl).then(function (res) { return res.json(); });
-}
-export function getValueByType(value, fieldType) {
-    try {
-        if (value === undefined) {
-            return undefined;
-        }
-        switch (fieldType) {
-            case "string":
-                return typeof value === "string" ? value : undefined;
-            case "integer":
-                return parseInt(value, 10);
-            case "double":
-                return parseFloat(value);
-            case "boolean":
-                return value === true;
-            case "array":
-                return Array.isArray(value) ? value : undefined;
-            case "object":
-                return typeof value === "object" ? value : undefined;
-            // @NOTE: `json` is not handled here intentionally
-            default:
-                return value;
-        }
-    }
-    catch (e) {
-        return undefined;
-    }
-}
-var FeaturevisorInstance = /** @class */ (function () {
-    function FeaturevisorInstance(options) {
-        var _this = this;
-        // from options
-        this.bucketKeySeparator = options.bucketKeySeparator || DEFAULT_BUCKET_KEY_SEPARATOR;
-        this.configureBucketKey = options.configureBucketKey;
-        this.configureBucketValue = options.configureBucketValue;
-        this.datafileUrl = options.datafileUrl;
-        this.handleDatafileFetch = options.handleDatafileFetch;
-        this.initialFeatures = options.initialFeatures;
-        this.interceptContext = options.interceptContext;
-        this.logger = options.logger || createLogger();
-        this.refreshInterval = options.refreshInterval;
-        this.stickyFeatures = options.stickyFeatures;
-        // internal
-        this.emitter = new Emitter();
-        this.statuses = {
-            ready: false,
-            refreshInProgress: false,
-        };
-        // register events
-        if (options.onReady) {
-            this.emitter.addListener("ready", options.onReady);
-        }
-        if (options.onRefresh) {
-            this.emitter.addListener("refresh", options.onRefresh);
-        }
-        if (options.onUpdate) {
-            this.emitter.addListener("update", options.onUpdate);
-        }
-        if (options.onActivation) {
-            this.emitter.addListener("activation", options.onActivation);
-        }
-        // expose emitter methods
-        var on = this.emitter.addListener.bind(this.emitter);
-        this.on = on;
-        this.addListener = on;
-        var off = this.emitter.removeListener.bind(this.emitter);
-        this.off = off;
-        this.removeListener = off;
-        this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);
-        // datafile
-        if (options.datafileUrl) {
-            this.setDatafile(options.datafile || emptyDatafile);
-            fetchDatafileContent(options.datafileUrl, options.handleDatafileFetch)
-                .then(function (datafile) {
-                _this.setDatafile(datafile);
-                _this.statuses.ready = true;
-                _this.emitter.emit("ready");
-                if (_this.refreshInterval) {
-                    _this.startRefreshing();
-                }
-            })
-                .catch(function (e) {
-                _this.logger.error("failed to fetch datafile", { error: e });
-            });
-        }
-        else if (options.datafile) {
-            this.setDatafile(options.datafile);
-            this.statuses.ready = true;
-            setTimeout(function () {
-                _this.emitter.emit("ready");
-            }, 0);
-        }
-        else {
-            throw new Error("Featurevisor SDK instance cannot be created without both `datafile` and `datafileUrl` options");
-        }
-    }
-    FeaturevisorInstance.prototype.setLogLevels = function (levels) {
-        this.logger.setLevels(levels);
-    };
-    FeaturevisorInstance.prototype.onReady = function () {
-        var _this = this;
-        return new Promise(function (resolve) {
-            if (_this.statuses.ready) {
-                return resolve(_this);
-            }
-            var cb = function () {
-                _this.emitter.removeListener("ready", cb);
-                resolve(_this);
-            };
-            _this.emitter.addListener("ready", cb);
-        });
-    };
-    FeaturevisorInstance.prototype.setDatafile = function (datafile) {
-        try {
-            this.datafileReader = new DatafileReader(typeof datafile === "string" ? JSON.parse(datafile) : datafile);
-        }
-        catch (e) {
-            this.logger.error("could not parse datafile", { error: e });
-        }
-    };
-    FeaturevisorInstance.prototype.setStickyFeatures = function (stickyFeatures) {
-        this.stickyFeatures = stickyFeatures;
-    };
-    FeaturevisorInstance.prototype.getRevision = function () {
-        return this.datafileReader.getRevision();
-    };
-    FeaturevisorInstance.prototype.getFeature = function (featureKey) {
-        return typeof featureKey === "string"
-            ? this.datafileReader.getFeature(featureKey) // only key provided
-            : featureKey; // full feature provided
-    };
-    /**
-     * Bucketing
-     */
-    FeaturevisorInstance.prototype.getBucketKey = function (feature, context) {
-        var featureKey = feature.key;
-        var type;
-        var attributeKeys;
-        if (typeof feature.bucketBy === "string") {
-            type = "plain";
-            attributeKeys = [feature.bucketBy];
-        }
-        else if (Array.isArray(feature.bucketBy)) {
-            type = "and";
-            attributeKeys = feature.bucketBy;
-        }
-        else if (typeof feature.bucketBy === "object" && Array.isArray(feature.bucketBy.or)) {
-            type = "or";
-            attributeKeys = feature.bucketBy.or;
-        }
-        else {
-            this.logger.error("invalid bucketBy", { featureKey: featureKey, bucketBy: feature.bucketBy });
-            throw new Error("invalid bucketBy");
-        }
-        var bucketKey = [];
-        attributeKeys.forEach(function (attributeKey) {
-            var attributeValue = context[attributeKey];
-            if (typeof attributeValue === "undefined") {
-                return;
-            }
-            if (type === "plain" || type === "and") {
-                bucketKey.push(attributeValue);
-            }
-            else {
-                // or
-                if (bucketKey.length === 0) {
-                    bucketKey.push(attributeValue);
-                }
-            }
-        });
-        bucketKey.push(featureKey);
-        var result = bucketKey.join(this.bucketKeySeparator);
-        if (this.configureBucketKey) {
-            return this.configureBucketKey(feature, context, result);
-        }
-        return result;
-    };
-    FeaturevisorInstance.prototype.getBucketValue = function (feature, context) {
-        var bucketKey = this.getBucketKey(feature, context);
-        var value = getBucketedNumber(bucketKey);
-        if (this.configureBucketValue) {
-            var configuredValue = this.configureBucketValue(feature, context, value);
-            return {
-                bucketKey: bucketKey,
-                bucketValue: configuredValue,
-            };
-        }
-        return {
-            bucketKey: bucketKey,
-            bucketValue: value,
-        };
-    };
-    /**
-     * Statuses
-     */
-    FeaturevisorInstance.prototype.isReady = function () {
-        return this.statuses.ready;
-    };
-    /**
-     * Refresh
-     */
-    FeaturevisorInstance.prototype.refresh = function () {
-        var _this = this;
-        this.logger.debug("refreshing datafile");
-        if (this.statuses.refreshInProgress) {
-            return this.logger.warn("refresh in progress, skipping");
-        }
-        if (!this.datafileUrl) {
-            return this.logger.error("cannot refresh since `datafileUrl` is not provided");
-        }
-        this.statuses.refreshInProgress = true;
-        fetchDatafileContent(this.datafileUrl, this.handleDatafileFetch)
-            .then(function (datafile) {
-            var currentRevision = _this.getRevision();
-            var newRevision = datafile.revision;
-            var isNotSameRevision = currentRevision !== newRevision;
-            _this.setDatafile(datafile);
-            _this.logger.info("refreshed datafile");
-            _this.emitter.emit("refresh");
-            if (isNotSameRevision) {
-                _this.emitter.emit("update");
-            }
-            _this.statuses.refreshInProgress = false;
-        })
-            .catch(function (e) {
-            _this.logger.error("failed to refresh datafile", { error: e });
-            _this.statuses.refreshInProgress = false;
-        });
-    };
-    FeaturevisorInstance.prototype.startRefreshing = function () {
-        var _this = this;
-        if (!this.datafileUrl) {
-            return this.logger.error("cannot start refreshing since `datafileUrl` is not provided");
-        }
-        if (this.intervalId) {
-            return this.logger.warn("refreshing has already started");
-        }
-        if (!this.refreshInterval) {
-            return this.logger.warn("no `refreshInterval` option provided");
-        }
-        this.intervalId = setInterval(function () {
-            _this.refresh();
-        }, this.refreshInterval * 1000);
-    };
-    FeaturevisorInstance.prototype.stopRefreshing = function () {
-        if (!this.intervalId) {
-            return this.logger.warn("refreshing has not started yet");
-        }
-        clearInterval(this.intervalId);
-    };
-    /**
-     * Flag
-     */
-    FeaturevisorInstance.prototype.evaluateFlag = function (featureKey, context) {
-        var _this = this;
-        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,
-                    sticky: this.stickyFeatures[key],
-                    enabled: this.stickyFeatures[key].enabled,
-                };
-                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,
-                    initial: this.initialFeatures[key],
-                    enabled: this.initialFeatures[key].enabled,
-                };
-                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;
-            }
-            // deprecated
-            if (feature.deprecated) {
-                this.logger.warn("feature is deprecated", { featureKey: feature.key });
-            }
-            var finalContext_1 = this.interceptContext ? this.interceptContext(context) : context;
-            // forced
-            var _a = findForceFromFeature(feature, context, this.datafileReader, this.logger), force = _a.force, forceIndex = _a.forceIndex;
-            if (force && typeof force.enabled !== "undefined") {
-                evaluation = {
-                    featureKey: feature.key,
-                    reason: EvaluationReason.FORCED,
-                    forceIndex: forceIndex,
-                    force: force,
-                    enabled: force.enabled,
-                };
-                this.logger.debug("forced enabled found", evaluation);
-                return evaluation;
-            }
-            // required
-            if (feature.required && feature.required.length > 0) {
-                var requiredFeaturesAreEnabled = feature.required.every(function (required) {
-                    var requiredKey;
-                    var requiredVariation;
-                    if (typeof required === "string") {
-                        requiredKey = required;
-                    }
-                    else {
-                        requiredKey = required.key;
-                        requiredVariation = required.variation;
-                    }
-                    var requiredIsEnabled = _this.isEnabled(requiredKey, finalContext_1);
-                    if (!requiredIsEnabled) {
-                        return false;
-                    }
-                    if (typeof requiredVariation !== "undefined") {
-                        var requiredVariationValue = _this.getVariation(requiredKey, finalContext_1);
-                        return requiredVariationValue === requiredVariation;
-                    }
-                    return true;
-                });
-                if (!requiredFeaturesAreEnabled) {
-                    evaluation = {
-                        featureKey: feature.key,
-                        reason: EvaluationReason.REQUIRED,
-                        required: feature.required,
-                        enabled: requiredFeaturesAreEnabled,
-                    };
-                    this.logger.debug("required features not enabled", evaluation);
-                    return evaluation;
-                }
-            }
-            // bucketing
-            var _b = this.getBucketValue(feature, finalContext_1), bucketKey = _b.bucketKey, bucketValue_1 = _b.bucketValue;
-            var matchedTraffic = getMatchedTraffic(feature.traffic, finalContext_1, this.datafileReader, this.logger);
-            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,
-                            bucketKey: bucketKey,
-                            bucketValue: bucketValue_1,
-                            ruleKey: matchedTraffic.key,
-                            traffic: matchedTraffic,
-                            enabled: typeof matchedTraffic.enabled === "undefined" ? true : matchedTraffic.enabled,
-                        };
-                        this.logger.debug("matched", evaluation);
-                        return evaluation;
-                    }
-                    // no match
-                    evaluation = {
-                        featureKey: feature.key,
-                        reason: EvaluationReason.OUT_OF_RANGE,
-                        bucketKey: bucketKey,
-                        bucketValue: bucketValue_1,
-                        enabled: false,
-                    };
-                    this.logger.debug("not matched", evaluation);
-                    return evaluation;
-                }
-                // override from rule
-                if (typeof matchedTraffic.enabled !== "undefined") {
-                    evaluation = {
-                        featureKey: feature.key,
-                        reason: EvaluationReason.OVERRIDE,
-                        bucketKey: bucketKey,
-                        bucketValue: bucketValue_1,
-                        ruleKey: matchedTraffic.key,
-                        traffic: matchedTraffic,
-                        enabled: matchedTraffic.enabled,
-                    };
-                    this.logger.debug("override from rule", evaluation);
-                    return evaluation;
-                }
-                // treated as enabled because of matched traffic
-                if (bucketValue_1 <= matchedTraffic.percentage) {
-                    evaluation = {
-                        featureKey: feature.key,
-                        reason: EvaluationReason.RULE,
-                        bucketKey: bucketKey,
-                        bucketValue: bucketValue_1,
-                        ruleKey: matchedTraffic.key,
-                        traffic: matchedTraffic,
-                        enabled: true,
-                    };
-                    this.logger.debug("matched traffic", evaluation);
-                    return evaluation;
-                }
-            }
-            // nothing matched
-            evaluation = {
-                featureKey: feature.key,
-                reason: EvaluationReason.NO_MATCH,
-                bucketKey: bucketKey,
-                bucketValue: bucketValue_1,
-                enabled: false,
-            };
-            this.logger.debug("nothing matched", evaluation);
-            return evaluation;
-        }
-        catch (e) {
-            evaluation = {
-                featureKey: typeof featureKey === "string" ? featureKey : featureKey.key,
-                reason: EvaluationReason.ERROR,
-                error: e,
-            };
-            this.logger.error("error", evaluation);
-            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, 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;
-                if (typeof variationValue !== "undefined") {
-                    evaluation = {
-                        featureKey: key,
-                        reason: EvaluationReason.STICKY,
-                        variationValue: variationValue,
-                    };
-                    this.logger.debug("using sticky variation", evaluation);
-                    return evaluation;
-                }
-            }
-            // initial
-            if (this.statuses &&
-                !this.statuses.ready &&
-                this.initialFeatures &&
-                this.initialFeatures[key] &&
-                typeof this.initialFeatures[key].variation !== "undefined") {
-                var variationValue = this.initialFeatures[key].variation;
-                evaluation = {
-                    featureKey: key,
-                    reason: EvaluationReason.INITIAL,
-                    variationValue: variationValue,
-                };
-                this.logger.debug("using initial variation", 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;
-            }
-            // 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 finalContext = this.interceptContext ? this.interceptContext(context) : context;
-            // forced
-            var _a = findForceFromFeature(feature, context, this.datafileReader, this.logger), force_1 = _a.force, forceIndex = _a.forceIndex;
-            if (force_1 && force_1.variation) {
-                var variation = feature.variations.find(function (v) { return v.value === force_1.variation; });
-                if (variation) {
-                    evaluation = {
-                        featureKey: feature.key,
-                        reason: EvaluationReason.FORCED,
-                        forceIndex: forceIndex,
-                        force: force_1,
-                        variation: variation,
-                    };
-                    this.logger.debug("forced variation found", evaluation);
-                    return evaluation;
-                }
-            }
-            // bucketing
-            var _b = this.getBucketValue(feature, finalContext), bucketKey = _b.bucketKey, bucketValue = _b.bucketValue;
-            var _c = getMatchedTrafficAndAllocation(feature.traffic, finalContext, bucketValue, this.datafileReader, this.logger), matchedTraffic_1 = _c.matchedTraffic, matchedAllocation_1 = _c.matchedAllocation;
-            if (matchedTraffic_1) {
-                // override from rule
-                if (matchedTraffic_1.variation) {
-                    var variation = feature.variations.find(function (v) { return v.value === matchedTraffic_1.variation; });
-                    if (variation) {
-                        evaluation = {
-                            featureKey: feature.key,
-                            reason: EvaluationReason.RULE,
-                            bucketKey: bucketKey,
-                            bucketValue: bucketValue,
-                            ruleKey: matchedTraffic_1.key,
-                            traffic: matchedTraffic_1,
-                            variation: variation,
-                        };
-                        this.logger.debug("override from rule", evaluation);
-                        return evaluation;
-                    }
-                }
-                // regular allocation
-                if (matchedAllocation_1 && matchedAllocation_1.variation) {
-                    var variation = feature.variations.find(function (v) { return v.value === matchedAllocation_1.variation; });
-                    if (variation) {
-                        evaluation = {
-                            featureKey: feature.key,
-                            reason: EvaluationReason.ALLOCATED,
-                            bucketKey: bucketKey,
-                            bucketValue: bucketValue,
-                            ruleKey: matchedTraffic_1.key,
-                            traffic: matchedTraffic_1,
-                            variation: variation,
-                        };
-                        this.logger.debug("allocated variation", evaluation);
-                        return evaluation;
-                    }
-                }
-            }
-            // nothing matched
-            evaluation = {
-                featureKey: feature.key,
-                reason: EvaluationReason.NO_MATCH,
-                bucketKey: bucketKey,
-                bucketValue: bucketValue,
-            };
-            this.logger.debug("no matched variation", evaluation);
-            return evaluation;
-        }
-        catch (e) {
-            evaluation = {
-                featureKey: typeof featureKey === "string" ? featureKey : featureKey.key,
-                reason: EvaluationReason.ERROR,
-                error: e,
-            };
-            this.logger.error("error", evaluation);
-            return evaluation;
-        }
-    };
-    FeaturevisorInstance.prototype.getVariation = function (featureKey, context) {
-        if (context === void 0) { context = {}; }
-        try {
-            var evaluation = this.evaluateVariation(featureKey, context);
-            if (typeof evaluation.variationValue !== "undefined") {
-                return evaluation.variationValue;
-            }
-            if (evaluation.variation) {
-                return evaluation.variation.value;
-            }
-            return undefined;
-        }
-        catch (e) {
-            this.logger.error("getVariation", { featureKey: featureKey, error: e });
-            return undefined;
-        }
-    };
-    /**
-     * Activate
-     */
-    FeaturevisorInstance.prototype.activate = function (featureKey, context) {
-        if (context === void 0) { context = {}; }
-        try {
-            var evaluation = this.evaluateVariation(featureKey, context);
-            var variationValue = evaluation.variation
-                ? evaluation.variation.value
-                : evaluation.variationValue;
-            if (typeof variationValue === "undefined") {
-                return undefined;
-            }
-            var finalContext_2 = 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 finalContext_2[a.key] !== "undefined") {
-                    captureContext_1[a.key] = context[a.key];
-                }
-            });
-            this.emitter.emit("activation", featureKey, variationValue, finalContext_2, captureContext_1, evaluation);
-            return variationValue;
-        }
-        catch (e) {
-            this.logger.error("activate", { featureKey: featureKey, error: e });
-            return undefined;
-        }
-    };
-    /**
-     * Variable
-     */
-    FeaturevisorInstance.prototype.evaluateVariable = function (featureKey, variableKey, context) {
-        var _this = this;
-        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 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]) {
-                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
-            if (!feature) {
-                evaluation = {
-                    featureKey: key,
-                    reason: EvaluationReason.NOT_FOUND,
-                    variableKey: variableKey,
-                };
-                this.logger.warn("feature not found in datafile", evaluation);
-                return evaluation;
-            }
-            var variableSchema = Array.isArray(feature.variablesSchema)
-                ? feature.variablesSchema.find(function (v) { return v.key === variableKey; })
-                : undefined;
-            // variable schema not found
-            if (!variableSchema) {
-                evaluation = {
-                    featureKey: key,
-                    reason: EvaluationReason.NOT_FOUND,
-                    variableKey: variableKey,
-                };
-                this.logger.warn("variable schema not found", evaluation);
-                return evaluation;
-            }
-            var finalContext_3 = this.interceptContext ? this.interceptContext(context) : context;
-            // forced
-            var _a = findForceFromFeature(feature, context, this.datafileReader, this.logger), force = _a.force, forceIndex = _a.forceIndex;
-            if (force && force.variables && typeof force.variables[variableKey] !== "undefined") {
-                evaluation = {
-                    featureKey: feature.key,
-                    reason: EvaluationReason.FORCED,
-                    forceIndex: forceIndex,
-                    force: force,
-                    variableKey: variableKey,
-                    variableSchema: variableSchema,
-                    variableValue: force.variables[variableKey],
-                };
-                this.logger.debug("forced variable", evaluation);
-                return evaluation;
-            }
-            // bucketing
-            var _b = this.getBucketValue(feature, finalContext_3), bucketKey = _b.bucketKey, bucketValue = _b.bucketValue;
-            var _c = getMatchedTrafficAndAllocation(feature.traffic, finalContext_3, bucketValue, this.datafileReader, this.logger), matchedTraffic = _c.matchedTraffic, matchedAllocation = _c.matchedAllocation;
-            if (matchedTraffic) {
-                // override from rule
-                if (matchedTraffic.variables &&
-                    typeof matchedTraffic.variables[variableKey] !== "undefined") {
-                    evaluation = {
-                        featureKey: feature.key,
-                        reason: EvaluationReason.RULE,
-                        bucketKey: bucketKey,
-                        bucketValue: bucketValue,
-                        ruleKey: matchedTraffic.key,
-                        traffic: matchedTraffic,
-                        variableKey: variableKey,
-                        variableSchema: variableSchema,
-                        variableValue: matchedTraffic.variables[variableKey],
-                    };
-                    this.logger.debug("override from rule", evaluation);
-                    return evaluation;
-                }
-                // regular allocation
-                var variationValue_1;
-                if (force && force.variation) {
-                    variationValue_1 = force.variation;
-                }
-                else if (matchedAllocation && matchedAllocation.variation) {
-                    variationValue_1 = matchedAllocation.variation;
-                }
-                if (variationValue_1 && Array.isArray(feature.variations)) {
-                    var variation = feature.variations.find(function (v) { return v.value === variationValue_1; });
-                    if (variation && variation.variables) {
-                        var variableFromVariation = variation.variables.find(function (v) { return v.key === variableKey; });
-                        if (variableFromVariation) {
-                            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, finalContext_3, _this.logger);
-                                    }
-                                    if (o.segments) {
-                                        return allGroupSegmentsAreMatched(parseFromStringifiedSegments(o.segments), finalContext_3, _this.datafileReader, _this.logger);
-                                    }
-                                    return false;
-                                });
-                                if (override) {
-                                    evaluation = {
-                                        featureKey: feature.key,
-                                        reason: EvaluationReason.OVERRIDE,
-                                        bucketKey: bucketKey,
-                                        bucketValue: bucketValue,
-                                        ruleKey: matchedTraffic.key,
-                                        traffic: matchedTraffic,
-                                        variableKey: variableKey,
-                                        variableSchema: variableSchema,
-                                        variableValue: override.value,
-                                    };
-                                    this.logger.debug("variable override", evaluation);
-                                    return evaluation;
-                                }
-                            }
-                            if (typeof variableFromVariation.value !== "undefined") {
-                                evaluation = {
-                                    featureKey: feature.key,
-                                    reason: EvaluationReason.ALLOCATED,
-                                    bucketKey: bucketKey,
-                                    bucketValue: bucketValue,
-                                    ruleKey: matchedTraffic.key,
-                                    traffic: matchedTraffic,
-                                    variableKey: variableKey,
-                                    variableSchema: variableSchema,
-                                    variableValue: variableFromVariation.value,
-                                };
-                                this.logger.debug("allocated variable", evaluation);
-                                return evaluation;
-                            }
-                        }
-                    }
-                }
-            }
-            // fall back to default
-            evaluation = {
-                featureKey: feature.key,
-                reason: EvaluationReason.DEFAULTED,
-                bucketKey: bucketKey,
-                bucketValue: bucketValue,
-                variableKey: variableKey,
-                variableSchema: variableSchema,
-                variableValue: variableSchema.defaultValue,
-            };
-            this.logger.debug("using default value", evaluation);
-            return evaluation;
-        }
-        catch (e) {
-            evaluation = {
-                featureKey: typeof featureKey === "string" ? featureKey : featureKey.key,
-                reason: EvaluationReason.ERROR,
-                variableKey: variableKey,
-                error: e,
-            };
-            this.logger.error("error", evaluation);
-            return evaluation;
-        }
-    };
-    FeaturevisorInstance.prototype.getVariable = function (featureKey, variableKey, context) {
-        if (context === void 0) { context = {}; }
-        try {
-            var evaluation = this.evaluateVariable(featureKey, variableKey, context);
-            if (typeof evaluation.variableValue !== "undefined") {
-                if (evaluation.variableSchema &&
-                    evaluation.variableSchema.type === "json" &&
-                    typeof evaluation.variableValue === "string") {
-                    return JSON.parse(evaluation.variableValue);
-                }
-                return evaluation.variableValue;
-            }
-            return undefined;
-        }
-        catch (e) {
-            this.logger.error("getVariable", { featureKey: featureKey, variableKey: variableKey, error: e });
-            return undefined;
-        }
-    };
-    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, context) {
-        if (context === void 0) { context = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, context);
-        return getValueByType(variableValue, "string");
-    };
-    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, context) {
-        if (context === void 0) { context = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, context);
-        return getValueByType(variableValue, "double");
-    };
-    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, context) {
-        if (context === void 0) { context = {}; }
-        var variableValue = this.getVariable(featureKey, variableKey, context);
-        return getValueByType(variableValue, "object");
-    };
-    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;
-}());
-export { FeaturevisorInstance };
-export function createInstance(options) {
-    return new FeaturevisorInstance(options);
-}
-//# sourceMappingURL=instance.js.map