@featurevisor/sdk 0.0.3

package/lib/datafileReader.js

@@ -0,0 +1,49 @@
+export function parseJsonConditionsIfStringified(record, key) {
+    if (typeof record[key] === "string" && record[key] !== "*") {
+        try {
+            record[key] = JSON.parse(record[key]);
+        }
+        catch (e) {
+            console.error("Error parsing JSON", e);
+        }
+    }
+    return record;
+}
+var DatafileReader = /** @class */ (function () {
+    function DatafileReader(datafileJson) {
+        this.schemaVersion = datafileJson.schemaVersion;
+        this.revision = datafileJson.revision;
+        this.segments = datafileJson.segments;
+        this.attributes = datafileJson.attributes;
+        this.features = datafileJson.features;
+    }
+    DatafileReader.prototype.getRevision = function () {
+        return this.revision;
+    };
+    DatafileReader.prototype.getSchemaVersion = function () {
+        return this.schemaVersion;
+    };
+    DatafileReader.prototype.getAllAttributes = function () {
+        return this.attributes;
+    };
+    DatafileReader.prototype.getAttribute = function (attributeKey) {
+        return this.attributes.find(function (a) { return a.key === attributeKey; });
+    };
+    DatafileReader.prototype.getSegment = function (segmentKey) {
+        var segment = this.segments.find(function (s) { return s.key === segmentKey; });
+        if (!segment) {
+            return undefined;
+        }
+        return parseJsonConditionsIfStringified(segment, "conditions");
+    };
+    DatafileReader.prototype.getFeature = function (featureKey) {
+        var feature = this.features.find(function (s) { return s.key === featureKey; });
+        if (!feature) {
+            return undefined;
+        }
+        return feature;
+    };
+    return DatafileReader;
+}());
+export { DatafileReader };
+//# sourceMappingURL=datafileReader.js.map

package/lib/datafileReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datafileReader.js","sourceRoot":"","sources":["../src/datafileReader.ts"],"names":[],"mappings":"AAUA,MAAM,UAAU,gCAAgC,CAAI,MAAS,EAAE,GAAW;IACxE,IAAI,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,GAAG,EAAE;QAC1D,IAAI;YACF,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;SACvC;QAAC,OAAO,CAAC,EAAE;YACV,OAAO,CAAC,KAAK,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;SACxC;KACF;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;IAOE,wBAAY,YAA6B;QACvC,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC,aAAa,CAAC;QAChD,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;QACtC,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;QACtC,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC;QAC1C,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;IACxC,CAAC;IAED,oCAAW,GAAX;QACE,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,yCAAgB,GAAhB;QACE,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,yCAAgB,GAAhB;QACE,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,qCAAY,GAAZ,UAAa,YAA0B;QACrC,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,GAAG,KAAK,YAAY,EAAtB,CAAsB,CAAC,CAAC;IAC7D,CAAC;IAED,mCAAU,GAAV,UAAW,UAAsB;QAC/B,IAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,GAAG,KAAK,UAAU,EAApB,CAAoB,CAAC,CAAC;QAEhE,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,SAAS,CAAC;SAClB;QAED,OAAO,gCAAgC,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACjE,CAAC;IAED,mCAAU,GAAV,UAAW,UAAsB;QAC/B,IAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAC,CAAC,IAAK,OAAA,CAAC,CAAC,GAAG,KAAK,UAAU,EAApB,CAAoB,CAAC,CAAC;QAEhE,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,SAAS,CAAC;SAClB;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IACH,qBAAC;AAAD,CAAC,AAlDD,IAkDC"}

package/lib/feature.d.ts

@@ -0,0 +1,8 @@
+import { Allocation, Attributes, Traffic, Feature, Variation, VariableKey, VariableValue } from "@featurevisor/types";
+import { DatafileReader } from "./datafileReader";
+export declare function getMatchedTraffic(traffic: Traffic[], attributes: Attributes, bucketValue: number, datafileReader: DatafileReader): Traffic | undefined;
+export declare function getMatchedAllocation(matchedTraffic: Traffic, bucketValue: number): Allocation | undefined;
+export declare function getForcedVariation(feature: Feature, attributes: Attributes, datafileReader: DatafileReader): Variation | undefined;
+export declare function getBucketedVariation(feature: Feature, attributes: Attributes, bucketValue: number, datafileReader: DatafileReader): Variation | undefined;
+export declare function getForcedVariableValue(feature: Feature, variableKey: VariableKey, attributes: Attributes, datafileReader: DatafileReader): VariableValue | undefined;
+export declare function getBucketedVariableValue(feature: Feature, variableKey: VariableKey, attributes: Attributes, bucketValue: number, datafileReader: DatafileReader): VariableValue | undefined;

package/lib/feature.js

@@ -0,0 +1,117 @@
+import { allGroupSegmentsAreMatched } from "./segments";
+import { allConditionsAreMatched } from "./conditions";
+export function getMatchedTraffic(traffic, attributes, bucketValue, datafileReader) {
+    return traffic.find(function (traffic) {
+        if (bucketValue > traffic.percentage) {
+            // out of bucket range
+            return false;
+        }
+        if (!allGroupSegmentsAreMatched(typeof traffic.segments === "string" && traffic.segments !== "*"
+            ? JSON.parse(traffic.segments)
+            : traffic.segments, attributes, datafileReader)) {
+            return false;
+        }
+        return true;
+    });
+}
+// @TODO: make this function better with tests
+export function getMatchedAllocation(matchedTraffic, bucketValue) {
+    var total = 0;
+    for (var _i = 0, _a = matchedTraffic.allocation; _i < _a.length; _i++) {
+        var allocation = _a[_i];
+        total += allocation.percentage;
+        if (bucketValue <= total) {
+            return allocation;
+        }
+    }
+    return undefined;
+}
+function findForceFromFeature(feature, attributes, datafileReader) {
+    if (!feature.force) {
+        return undefined;
+    }
+    return feature.force.find(function (f) {
+        if (f.conditions) {
+            return allConditionsAreMatched(f.conditions, attributes);
+        }
+        if (f.segments) {
+            return allGroupSegmentsAreMatched(f.segments, attributes, datafileReader);
+        }
+        return false;
+    });
+}
+export function getForcedVariation(feature, attributes, datafileReader) {
+    var force = findForceFromFeature(feature, attributes, datafileReader);
+    if (!force || !force.variation) {
+        return undefined;
+    }
+    return feature.variations.find(function (v) { return v.value === force.variation; });
+}
+export function getBucketedVariation(feature, attributes, bucketValue, datafileReader) {
+    var matchedTraffic = getMatchedTraffic(feature.traffic, attributes, bucketValue, datafileReader);
+    if (!matchedTraffic) {
+        return undefined;
+    }
+    var allocation = getMatchedAllocation(matchedTraffic, bucketValue);
+    if (!allocation) {
+        return undefined;
+    }
+    var variationValue = allocation.variation;
+    var variation = feature.variations.find(function (v) {
+        return v.value === variationValue;
+    });
+    if (!variation) {
+        return undefined;
+    }
+    return variation;
+}
+export function getForcedVariableValue(feature, variableKey, attributes, datafileReader) {
+    var force = findForceFromFeature(feature, attributes, datafileReader);
+    if (!force || !force.variables) {
+        return undefined;
+    }
+    return force.variables[variableKey];
+}
+export function getBucketedVariableValue(feature, variableKey, attributes, bucketValue, datafileReader) {
+    var _a;
+    // all variables
+    var variablesSchema = feature.variablesSchema;
+    if (!variablesSchema) {
+        return undefined;
+    }
+    // single variable
+    var variableSchema = variablesSchema.find(function (v) {
+        v.key === variableKey;
+    });
+    if (variableSchema) {
+        return undefined;
+    }
+    var variation = getBucketedVariation(feature, attributes, bucketValue, datafileReader);
+    if (!variation) {
+        return undefined;
+    }
+    var variableFromVariation = (_a = variation.variables) === null || _a === void 0 ? void 0 : _a.find(function (v) {
+        return v.key === variableKey;
+    });
+    if (!variableFromVariation) {
+        return undefined;
+    }
+    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, attributes);
+            }
+            if (o.segments) {
+                return allGroupSegmentsAreMatched(typeof o.segments === "string" && o.segments !== "*"
+                    ? JSON.parse(o.segments)
+                    : o.segments, attributes, datafileReader);
+            }
+            return false;
+        });
+        if (override) {
+            return override.value;
+        }
+    }
+    return variableFromVariation.value;
+}
+//# sourceMappingURL=feature.js.map

package/lib/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.js","sourceRoot":"","sources":["../src/feature.ts"],"names":[],"mappings":"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"}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./bucket";
+export * from "./client";

package/lib/index.js

@@ -0,0 +1,3 @@
+export * from "./bucket";
+export * from "./client";
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/lib/segments.d.ts

@@ -0,0 +1,4 @@
+import { Attributes, GroupSegment, Segment } from "@featurevisor/types";
+import { DatafileReader } from "./datafileReader";
+export declare function segmentIsMatched(segment: Segment, attributes: Attributes): boolean;
+export declare function allGroupSegmentsAreMatched(groupSegments: GroupSegment | GroupSegment[] | "*", attributes: Attributes, datafileReader: DatafileReader): boolean;

package/lib/segments.js

@@ -0,0 +1,35 @@
+import { allConditionsAreMatched } from "./conditions";
+export function segmentIsMatched(segment, attributes) {
+    return allConditionsAreMatched(segment.conditions, attributes);
+}
+export function allGroupSegmentsAreMatched(groupSegments, attributes, datafileReader) {
+    if (groupSegments === "*") {
+        return true;
+    }
+    if (typeof groupSegments === "string") {
+        var segment = datafileReader.getSegment(groupSegments);
+        if (segment) {
+            return segmentIsMatched(segment, attributes);
+        }
+        return false;
+    }
+    if (typeof groupSegments === "object") {
+        if ("and" in groupSegments && Array.isArray(groupSegments.and)) {
+            return groupSegments.and.every(function (groupSegment) {
+                return allGroupSegmentsAreMatched(groupSegment, attributes, datafileReader);
+            });
+        }
+        if ("or" in groupSegments && Array.isArray(groupSegments.or)) {
+            return groupSegments.or.some(function (groupSegment) {
+                return allGroupSegmentsAreMatched(groupSegment, attributes, datafileReader);
+            });
+        }
+    }
+    if (Array.isArray(groupSegments)) {
+        return groupSegments.every(function (groupSegment) {
+            return allGroupSegmentsAreMatched(groupSegment, attributes, datafileReader);
+        });
+    }
+    return false;
+}
+//# sourceMappingURL=segments.js.map

package/lib/segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.js","sourceRoot":"","sources":["../src/segments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAGvD,MAAM,UAAU,gBAAgB,CAAC,OAAgB,EAAE,UAAsB;IACvE,OAAO,uBAAuB,CAAC,OAAO,CAAC,UAAqC,EAAE,UAAU,CAAC,CAAC;AAC5F,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,aAAkD,EAClD,UAAsB,EACtB,cAA8B;IAE9B,IAAI,aAAa,KAAK,GAAG,EAAE;QACzB,OAAO,IAAI,CAAC;KACb;IAED,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE;QACrC,IAAM,OAAO,GAAG,cAAc,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAEzD,IAAI,OAAO,EAAE;YACX,OAAO,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;SAC9C;QAED,OAAO,KAAK,CAAC;KACd;IAED,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE;QACrC,IAAI,KAAK,IAAI,aAAa,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE;YAC9D,OAAO,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,UAAC,YAAY;gBAC1C,OAAA,0BAA0B,CAAC,YAAY,EAAE,UAAU,EAAE,cAAc,CAAC;YAApE,CAAoE,CACrE,CAAC;SACH;QAED,IAAI,IAAI,IAAI,aAAa,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE;YAC5D,OAAO,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,UAAC,YAAY;gBACxC,OAAA,0BAA0B,CAAC,YAAY,EAAE,UAAU,EAAE,cAAc,CAAC;YAApE,CAAoE,CACrE,CAAC;SACH;KACF;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;QAChC,OAAO,aAAa,CAAC,KAAK,CAAC,UAAC,YAAY;YACtC,OAAA,0BAA0B,CAAC,YAAY,EAAE,UAAU,EAAE,cAAc,CAAC;QAApE,CAAoE,CACrE,CAAC;KACH;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/lib/segments.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@featurevisor/sdk",
+  "version": "0.0.3",
+  "description": "Featurevisor SDK for Node.js and the browser",
+  "main": "dist/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "lint": "echo 'not linting in this package yet'",
+    "transpile": "rimraf lib && tsc --project tsconfig.esm.json",
+    "dist": "webpack --config ./webpack.config.js",
+    "build": "npm run transpile && npm run dist",
+    "test": "jest --config ../../jest.config.js --verbose"
+  },
+  "author": {
+    "name": "Fahad Heylaal",
+    "url": "https://fahad19.com"
+  },
+  "homepage": "https://featurevisor.com",
+  "keywords": [
+    "featurevisor",
+    "feature",
+    "features",
+    "flags",
+    "feature flags",
+    "feature toggles",
+    "feature management",
+    "experimentation",
+    "experiment",
+    "experiments"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fahad19/featurevisor.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bugs": {
+    "url": "https://github.com/fahad19/featurevisor/issues"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@featurevisor/types": "^0.0.3",
+    "murmurhash": "^2.0.1"
+  },
+  "gitHead": "303aca84f7c32163cb1079513d799296bd892e72"
+}

package/src/bucket.spec.ts

@@ -0,0 +1,18 @@
+import { getBucketedNumber, MAX_BUCKETED_NUMBER } from "./bucket";
+
+describe("sdk: Bucket", function () {
+  it("should be a function", function () {
+    expect(typeof getBucketedNumber).toEqual("function");
+  });
+
+  it("should return a number between 0 and 100000", function () {
+    const keys = ["foo", "bar", "baz", "123adshlk348-93asdlk"];
+
+    keys.forEach((key) => {
+      const n = getBucketedNumber(key);
+
+      expect(n >= 0).toEqual(true);
+      expect(n <= MAX_BUCKETED_NUMBER).toEqual(true);
+    });
+  });
+});

package/src/bucket.ts

@@ -0,0 +1,13 @@
+import * as murmurhash from "murmurhash";
+
+const HASH_SEED = 1;
+const MAX_HASH_VALUE = Math.pow(2, 32);
+
+export const MAX_BUCKETED_NUMBER = 100000; // 100% * 1000 to include three decimal places in the same integer value
+
+export function getBucketedNumber(bucketKey: string): number {
+  const hashValue = murmurhash.v3(bucketKey, HASH_SEED);
+  const ratio = hashValue / MAX_HASH_VALUE;
+
+  return Math.floor(ratio * MAX_BUCKETED_NUMBER);
+}

package/src/client.ts

@@ -0,0 +1,338 @@
+import {
+  Attributes,
+  VariationValue,
+  VariableValue,
+  Feature,
+  DatafileContent,
+  BucketKey,
+  BucketValue,
+  FeatureKey,
+} from "@featurevisor/types";
+import { DatafileReader } from "./datafileReader";
+import {
+  getBucketedVariation,
+  getBucketedVariableValue,
+  getForcedVariation,
+  getForcedVariableValue,
+} from "./feature";
+import { getBucketedNumber } from "./bucket";
+
+export type ActivationCallback = (
+  featureName: string,
+  variation: VariationValue,
+  attributes: Attributes,
+  captureAttributes: Attributes,
+) => void;
+
+export type ConfigureBucketValue = (feature, attributes, bucketValue: BucketValue) => BucketValue;
+export interface SdkOptions {
+  datafile: DatafileContent | string;
+  onActivation?: ActivationCallback;
+  configureBucketValue?: ConfigureBucketValue;
+}
+
+// union of VariableValue and VariationValue
+type FieldType = "string" | "integer" | "double" | "boolean" | "array";
+type ValueType = string | number | boolean | string[] | null | undefined;
+
+export function getValueByType(value: ValueType, fieldType: FieldType): ValueType {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  switch (fieldType) {
+    case "string":
+      return typeof value === "string" ? value : undefined;
+    case "integer":
+      return parseInt(value as string, 10);
+    case "double":
+      return parseFloat(value as string);
+    case "boolean":
+      return value === true;
+    case "array":
+      return Array.isArray(value) ? value : undefined;
+    default:
+      return value;
+  }
+}
+
+export class FeaturevisorSDK {
+  private onActivation?: ActivationCallback;
+  private datafileReader: DatafileReader;
+  private configureBucketValue?: ConfigureBucketValue;
+
+  constructor(options: SdkOptions) {
+    if (options.onActivation) {
+      this.onActivation = options.onActivation;
+    }
+
+    if (options.configureBucketValue) {
+      this.configureBucketValue = options.configureBucketValue;
+    }
+
+    try {
+      this.datafileReader = new DatafileReader(
+        typeof options.datafile === "string" ? JSON.parse(options.datafile) : options.datafile,
+      );
+    } catch (e) {
+      console.error(`Featurevisor could not parse the datafile`);
+      console.error(e);
+    }
+  }
+
+  private getFeature(featureKey: string | Feature): Feature | undefined {
+    return typeof featureKey === "string"
+      ? this.datafileReader.getFeature(featureKey) // only key provided
+      : featureKey; // full feature provided
+  }
+
+  /**
+   * Bucketing
+   */
+
+  private getBucketKey(feature: Feature, attributes: Attributes): BucketKey {
+    const featureKey = feature.key;
+
+    const prefix =
+      typeof feature.bucketBy === "string" ? feature.bucketBy : feature.bucketBy.join("_");
+
+    return `${prefix}_${featureKey}`;
+  }
+
+  private getBucketValue(feature: Feature, attributes: Attributes): BucketValue {
+    const bucketKey = this.getBucketKey(feature, attributes);
+
+    const value = getBucketedNumber(bucketKey);
+
+    if (this.configureBucketValue) {
+      return this.configureBucketValue(feature, attributes, value);
+    }
+
+    return value;
+  }
+
+  /**
+   * Variation
+   */
+
+  getVariation(
+    featureKey: FeatureKey | Feature,
+    attributes: Attributes = {},
+  ): VariationValue | undefined {
+    try {
+      const feature = this.getFeature(featureKey);
+
+      if (!feature) {
+        return undefined;
+      }
+
+      const forcedVariation = getForcedVariation(feature, attributes, this.datafileReader);
+
+      if (forcedVariation) {
+        return forcedVariation.value;
+      }
+
+      const bucketValue = this.getBucketValue(feature, attributes);
+
+      const variation = getBucketedVariation(feature, attributes, bucketValue, this.datafileReader);
+
+      if (!variation) {
+        return undefined;
+      }
+
+      return variation.value;
+    } catch (e) {
+      console.error("[Featurevisor]", e);
+
+      return undefined;
+    }
+  }
+
+  getVariationBoolean(
+    featureKey: FeatureKey | Feature,
+    attributes: Attributes = {},
+  ): boolean | undefined {
+    const variationValue = this.getVariation(featureKey, attributes);
+
+    return getValueByType(variationValue, "boolean") as boolean | undefined;
+  }
+
+  getVariationString(
+    featureKey: FeatureKey | Feature,
+    attributes: Attributes = {},
+  ): string | undefined {
+    const variationValue = this.getVariation(featureKey, attributes);
+
+    return getValueByType(variationValue, "string") as string | undefined;
+  }
+
+  getVariationInteger(
+    featureKey: FeatureKey | Feature,
+    attributes: Attributes = {},
+  ): number | undefined {
+    const variationValue = this.getVariation(featureKey, attributes);
+
+    return getValueByType(variationValue, "integer") as number | undefined;
+  }
+
+  getVariationDouble(
+    featureKey: FeatureKey | Feature,
+    attributes: Attributes = {},
+  ): number | undefined {
+    const variationValue = this.getVariation(featureKey, attributes);
+
+    return getValueByType(variationValue, "double") as number | undefined;
+  }
+
+  /**
+   * Activate
+   */
+  activate(featureKey: FeatureKey, attributes: Attributes = {}): VariationValue | undefined {
+    try {
+      const variationValue = this.getVariation(featureKey, attributes);
+
+      if (!variationValue) {
+        return undefined;
+      }
+
+      if (this.onActivation) {
+        const captureAttributes: Attributes = {};
+
+        const attributesForCapturing = this.datafileReader
+          .getAllAttributes()
+          .filter((a) => a.capture === true);
+
+        attributesForCapturing.forEach((a) => {
+          if (typeof attributes[a.key] !== "undefined") {
+            captureAttributes[a.key] = attributes[a.key];
+          }
+        });
+
+        this.onActivation(featureKey, variationValue, attributes, captureAttributes);
+      }
+
+      return variationValue;
+    } catch (e) {
+      console.error("[Featurevisor]", e);
+
+      return undefined;
+    }
+  }
+
+  activateBoolean(featureKey: FeatureKey, attributes: Attributes = {}): boolean | undefined {
+    const variationValue = this.activate(featureKey, attributes);
+
+    return getValueByType(variationValue, "boolean") as boolean | undefined;
+  }
+
+  activateString(featureKey: FeatureKey, attributes: Attributes = {}): string | undefined {
+    const variationValue = this.activate(featureKey, attributes);
+
+    return getValueByType(variationValue, "string") as string | undefined;
+  }
+
+  activateInteger(featureKey: FeatureKey, attributes: Attributes = {}): number | undefined {
+    const variationValue = this.activate(featureKey, attributes);
+
+    return getValueByType(variationValue, "integer") as number | undefined;
+  }
+
+  activateDouble(featureKey: FeatureKey, attributes: Attributes = {}): number | undefined {
+    const variationValue = this.activate(featureKey, attributes);
+
+    return getValueByType(variationValue, "double") as number | undefined;
+  }
+
+  /**
+   * Variable
+   */
+
+  getVariable(
+    featureKey: FeatureKey | Feature,
+    variableKey: string,
+    attributes: Attributes = {},
+  ): VariableValue | undefined {
+    try {
+      const feature = this.getFeature(featureKey);
+
+      if (!feature) {
+        return undefined;
+      }
+
+      const forcedVariableValue = getForcedVariableValue(
+        feature,
+        variableKey,
+        attributes,
+        this.datafileReader,
+      );
+
+      if (typeof forcedVariableValue !== "undefined") {
+        return forcedVariableValue;
+      }
+
+      const bucketValue = this.getBucketValue(feature, attributes);
+
+      return getBucketedVariableValue(
+        feature,
+        variableKey,
+        attributes,
+        bucketValue,
+        this.datafileReader,
+      );
+    } catch (e) {
+      console.error("[Featurevisor]", e);
+
+      return undefined;
+    }
+  }
+
+  getVariableBoolean(
+    featureKey: FeatureKey | Feature,
+    variableKey: string,
+    attributes: Attributes = {},
+  ): boolean | undefined {
+    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+
+    return getValueByType(variableValue, "boolean") as boolean | undefined;
+  }
+
+  getVariableString(
+    featureKey: FeatureKey | Feature,
+    variableKey: string,
+    attributes: Attributes = {},
+  ): string | undefined {
+    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+
+    return getValueByType(variableValue, "string") as string | undefined;
+  }
+
+  getVariableInteger(
+    featureKey: FeatureKey | Feature,
+    variableKey: string,
+    attributes: Attributes = {},
+  ): number | undefined {
+    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+
+    return getValueByType(variableValue, "integer") as number | undefined;
+  }
+
+  getVariableDouble(
+    featureKey: FeatureKey | Feature,
+    variableKey: string,
+    attributes: Attributes = {},
+  ): number | undefined {
+    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+
+    return getValueByType(variableValue, "double") as number | undefined;
+  }
+
+  getVariableArray(
+    featureKey: FeatureKey | Feature,
+    variableKey: string,
+    attributes: Attributes = {},
+  ): string[] | undefined {
+    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+
+    return getValueByType(variableValue, "array") as string[] | undefined;
+  }
+}