flagsmith-nodejs 2.0.0-beta.5 → 2.0.0-beta.6

package/build/flagsmith-engine/organisations/util.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildOrganizationModel = void 0;
-const models_1 = require("./models");
+var models_1 = require("./models");
 function buildOrganizationModel(organizationJSON) {
     return new models_1.OrganisationModel(organizationJSON.id, organizationJSON.name, organizationJSON.feature_analytics, organizationJSON.stop_serving_flags, organizationJSON.persist_trait_data);
 }

package/build/flagsmith-engine/projects/models.js

@@ -1,17 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectModel = void 0;
-class ProjectModel {
-    id;
-    name;
-    organisation;
-    hideDisabledFlags;
-    segments = [];
-    constructor(id, name, hideDisabledFlags, organization) {
+var ProjectModel = /** @class */ (function () {
+    function ProjectModel(id, name, hideDisabledFlags, organization) {
+        this.segments = [];
         this.id = id;
         this.name = name;
         this.hideDisabledFlags = hideDisabledFlags;
         this.organisation = organization;
     }
-}
+    return ProjectModel;
+}());
 exports.ProjectModel = ProjectModel;

package/build/flagsmith-engine/projects/util.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildProjectModel = void 0;
-const util_1 = require("../organisations/util");
-const util_2 = require("../segments/util");
-const models_1 = require("./models");
+var util_1 = require("../organisations/util");
+var util_2 = require("../segments/util");
+var models_1 = require("./models");
 function buildProjectModel(projectJSON) {
-    const segments = projectJSON['segments']
-        ? projectJSON['segments'].map((s) => (0, util_2.buildSegmentModel)(s))
+    var segments = projectJSON['segments']
+        ? projectJSON['segments'].map(function (s) { return (0, util_2.buildSegmentModel)(s); })
         : [];
-    const model = new models_1.ProjectModel(projectJSON.id, projectJSON.name, projectJSON.hide_disabled_flags, (0, util_1.buildOrganizationModel)(projectJSON.organisation));
+    var model = new models_1.ProjectModel(projectJSON.id, projectJSON.name, projectJSON.hide_disabled_flags, (0, util_1.buildOrganizationModel)(projectJSON.organisation));
     model.segments = segments;
     return model;
 }

package/build/flagsmith-engine/segments/evaluators.js

@@ -1,29 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateIdentityInSegment = exports.getIdentitySegments = void 0;
-const hashing_1 = require("../utils/hashing");
-const constants_1 = require("./constants");
+var hashing_1 = require("../utils/hashing");
+var constants_1 = require("./constants");
 function getIdentitySegments(environment, identity, overrideTraits) {
-    return environment.project.segments.filter(segment => evaluateIdentityInSegment(identity, segment, overrideTraits));
+    return environment.project.segments.filter(function (segment) {
+        return evaluateIdentityInSegment(identity, segment, overrideTraits);
+    });
 }
 exports.getIdentitySegments = getIdentitySegments;
 function evaluateIdentityInSegment(identity, segment, overrideTraits) {
     return (segment.rules.length > 0 &&
-        segment.rules.filter(rule => traitsMatchSegmentRule(overrideTraits || identity.identityTraits, rule, segment.id, identity.compositeKey)).length === segment.rules.length);
+        segment.rules.filter(function (rule) {
+            return traitsMatchSegmentRule(overrideTraits || identity.identityTraits, rule, segment.id, identity.compositeKey);
+        }).length === segment.rules.length);
 }
 exports.evaluateIdentityInSegment = evaluateIdentityInSegment;
 function traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId) {
-    const matchesConditions = rule.conditions.length > 0
-        ? rule.matchingFunction()(rule.conditions.map(condition => traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId)))
+    var matchesConditions = rule.conditions.length > 0
+        ? rule.matchingFunction()(rule.conditions.map(function (condition) {
+            return traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId);
+        }))
         : true;
     return (matchesConditions &&
-        rule.rules.filter(rule => traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId)).length === rule.rules.length);
+        rule.rules.filter(function (rule) {
+            return traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId);
+        }).length === rule.rules.length);
 }
 function traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId) {
     if (condition.operator == constants_1.PERCENTAGE_SPLIT) {
         return (0, hashing_1.getHashedPercentateForObjIds)([segmentId, identityId]) <= parseFloat(condition.value);
     }
-    const traits = identityTraits.filter(t => t.traitKey === condition.property_);
-    const trait = traits.length > 0 ? traits[0] : undefined;
+    var traits = identityTraits.filter(function (t) { return t.traitKey === condition.property_; });
+    var trait = traits.length > 0 ? traits[0] : undefined;
     return trait ? condition.matchesTraitValue(trait.traitValue) : false;
 }

package/build/flagsmith-engine/segments/models.js

@@ -1,83 +1,92 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentModel = exports.SegmentRuleModel = exports.SegmentConditionModel = exports.matchingFunctions = exports.any = exports.all = void 0;
-const utils_1 = require("../utils");
-const constants_1 = require("./constants");
-const all = (iterable) => iterable.filter(e => !!e).length === iterable.length;
+var utils_1 = require("../utils");
+var constants_1 = require("./constants");
+var all = function (iterable) { return iterable.filter(function (e) { return !!e; }).length === iterable.length; };
 exports.all = all;
-const any = (iterable) => iterable.filter(e => !!e).length > 0;
+var any = function (iterable) { return iterable.filter(function (e) { return !!e; }).length > 0; };
 exports.any = any;
-exports.matchingFunctions = {
-    [constants_1.CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => thisValue == otherValue,
-    [constants_1.CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => otherValue > thisValue,
-    [constants_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => otherValue >= thisValue,
-    [constants_1.CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => thisValue > otherValue,
-    [constants_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => thisValue >= otherValue,
-    [constants_1.CONDITION_OPERATORS.NOT_EQUAL]: (thisValue, otherValue) => thisValue != otherValue,
-    [constants_1.CONDITION_OPERATORS.CONTAINS]: (thisValue, otherValue) => otherValue.includes(thisValue),
-    [constants_1.CONDITION_OPERATORS.NOT_CONTAINS]: (thisValue, otherValue) => !otherValue.includes(thisValue)
-};
-class SegmentConditionModel {
-    EXCEPTION_OPERATOR_METHODS = {
-        [constants_1.NOT_CONTAINS]: 'evaluateNotContains',
-        [constants_1.REGEX]: 'evaluateRegex'
-    };
-    operator;
-    value;
-    property_;
-    constructor(operator, value, property) {
+exports.matchingFunctions = (_a = {},
+    _a[constants_1.CONDITION_OPERATORS.EQUAL] = function (thisValue, otherValue) { return thisValue == otherValue; },
+    _a[constants_1.CONDITION_OPERATORS.GREATER_THAN] = function (thisValue, otherValue) { return otherValue > thisValue; },
+    _a[constants_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE] = function (thisValue, otherValue) {
+        return otherValue >= thisValue;
+    },
+    _a[constants_1.CONDITION_OPERATORS.LESS_THAN] = function (thisValue, otherValue) { return thisValue > otherValue; },
+    _a[constants_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE] = function (thisValue, otherValue) {
+        return thisValue >= otherValue;
+    },
+    _a[constants_1.CONDITION_OPERATORS.NOT_EQUAL] = function (thisValue, otherValue) { return thisValue != otherValue; },
+    _a[constants_1.CONDITION_OPERATORS.CONTAINS] = function (thisValue, otherValue) {
+        return otherValue.includes(thisValue);
+    },
+    _a[constants_1.CONDITION_OPERATORS.NOT_CONTAINS] = function (thisValue, otherValue) {
+        return !otherValue.includes(thisValue);
+    },
+    _a);
+var SegmentConditionModel = /** @class */ (function () {
+    function SegmentConditionModel(operator, value, property) {
+        var _a;
+        this.EXCEPTION_OPERATOR_METHODS = (_a = {},
+            _a[constants_1.NOT_CONTAINS] = 'evaluateNotContains',
+            _a[constants_1.REGEX] = 'evaluateRegex',
+            _a);
         this.operator = operator;
         this.value = value;
         this.property_ = property;
     }
-    matchesTraitValue(traitValue) {
-        const evaluators = {
-            evaluateNotContains: (traitValue) => {
-                return !traitValue.includes(this.value);
+    SegmentConditionModel.prototype.matchesTraitValue = function (traitValue) {
+        var _this = this;
+        var evaluators = {
+            evaluateNotContains: function (traitValue) {
+                return !traitValue.includes(_this.value);
             },
-            evaluateRegex: (traitValue) => {
-                return !!traitValue.match(new RegExp(this.value));
+            evaluateRegex: function (traitValue) {
+                return !!traitValue.match(new RegExp(_this.value));
             }
         };
         // TODO: move this logic to the evaluator module
         if (this.EXCEPTION_OPERATOR_METHODS[this.operator]) {
-            const evaluatorFunction = evaluators[this.EXCEPTION_OPERATOR_METHODS[this.operator]];
+            var evaluatorFunction = evaluators[this.EXCEPTION_OPERATOR_METHODS[this.operator]];
             return evaluatorFunction(traitValue);
         }
-        const defaultFunction = (x, y) => false;
-        const matchingFunction = exports.matchingFunctions[this.operator] || defaultFunction;
-        const castToTypeOfTraitValue = (0, utils_1.getCastingFunction)(traitValue);
+        var defaultFunction = function (x, y) { return false; };
+        var matchingFunction = exports.matchingFunctions[this.operator] || defaultFunction;
+        var castToTypeOfTraitValue = (0, utils_1.getCastingFunction)(traitValue);
         return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
-    }
-}
+    };
+    return SegmentConditionModel;
+}());
 exports.SegmentConditionModel = SegmentConditionModel;
-class SegmentRuleModel {
-    type;
-    rules = [];
-    conditions = [];
-    constructor(type) {
+var SegmentRuleModel = /** @class */ (function () {
+    function SegmentRuleModel(type) {
+        this.rules = [];
+        this.conditions = [];
         this.type = type;
     }
-    static none(iterable) {
-        return iterable.filter(e => !!e).length === 0;
-    }
-    matchingFunction() {
-        return {
-            [constants_1.ANY_RULE]: exports.any,
-            [constants_1.ALL_RULE]: exports.all,
-            [constants_1.NONE_RULE]: SegmentRuleModel.none
-        }[this.type];
-    }
-}
+    SegmentRuleModel.none = function (iterable) {
+        return iterable.filter(function (e) { return !!e; }).length === 0;
+    };
+    SegmentRuleModel.prototype.matchingFunction = function () {
+        var _a;
+        return (_a = {},
+            _a[constants_1.ANY_RULE] = exports.any,
+            _a[constants_1.ALL_RULE] = exports.all,
+            _a[constants_1.NONE_RULE] = SegmentRuleModel.none,
+            _a)[this.type];
+    };
+    return SegmentRuleModel;
+}());
 exports.SegmentRuleModel = SegmentRuleModel;
-class SegmentModel {
-    id;
-    name;
-    rules = [];
-    featureStates = [];
-    constructor(id, name) {
+var SegmentModel = /** @class */ (function () {
+    function SegmentModel(id, name) {
+        this.rules = [];
+        this.featureStates = [];
         this.id = id;
         this.name = name;
     }
-}
+    return SegmentModel;
+}());
 exports.SegmentModel = SegmentModel;

package/build/flagsmith-engine/segments/util.js

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSegmentModel = exports.buildSegmentRuleModel = exports.buildSegmentConditionModel = void 0;
-const util_1 = require("../features/util");
-const models_1 = require("./models");
+var util_1 = require("../features/util");
+var models_1 = require("./models");
 function buildSegmentConditionModel(segmentConditionJSON) {
     return new models_1.SegmentConditionModel(segmentConditionJSON.operator, segmentConditionJSON.value, segmentConditionJSON.property_);
 }
 exports.buildSegmentConditionModel = buildSegmentConditionModel;
 function buildSegmentRuleModel(ruleModelJSON) {
-    const ruleModel = new models_1.SegmentRuleModel(ruleModelJSON.type);
-    ruleModel.rules = ruleModelJSON.rules.map((r) => buildSegmentRuleModel(r));
-    ruleModel.conditions = ruleModelJSON.conditions.map((c) => buildSegmentConditionModel(c));
+    var ruleModel = new models_1.SegmentRuleModel(ruleModelJSON.type);
+    ruleModel.rules = ruleModelJSON.rules.map(function (r) { return buildSegmentRuleModel(r); });
+    ruleModel.conditions = ruleModelJSON.conditions.map(function (c) { return buildSegmentConditionModel(c); });
     return ruleModel;
 }
 exports.buildSegmentRuleModel = buildSegmentRuleModel;
 function buildSegmentModel(segmentModelJSON) {
-    const model = new models_1.SegmentModel(segmentModelJSON.id, segmentModelJSON.name);
-    model.featureStates = segmentModelJSON['feature_states'].map((fs) => (0, util_1.buildFeatureStateModel)(fs));
-    model.rules = segmentModelJSON['rules'].map((r) => buildSegmentRuleModel(r));
+    var model = new models_1.SegmentModel(segmentModelJSON.id, segmentModelJSON.name);
+    model.featureStates = segmentModelJSON['feature_states'].map(function (fs) {
+        return (0, util_1.buildFeatureStateModel)(fs);
+    });
+    model.rules = segmentModelJSON['rules'].map(function (r) { return buildSegmentRuleModel(r); });
     return model;
 }
 exports.buildSegmentModel = buildSegmentModel;

package/build/flagsmith-engine/utils/collections.js

@@ -1,16 +1,97 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdentityFeaturesList = void 0;
-class IdentityFeaturesList extends Array {
-    push(...e) {
-        for (const [_, item] of e.entries()) {
-            for (const [k, v] of this.entries()) {
-                if (v.djangoID === item.djangoID) {
-                    throw new Error('feature state for this feature already exists');
+var IdentityFeaturesList = /** @class */ (function (_super) {
+    __extends(IdentityFeaturesList, _super);
+    function IdentityFeaturesList() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    IdentityFeaturesList.prototype.push = function () {
+        var e_1, _a, e_2, _b;
+        var e = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            e[_i] = arguments[_i];
+        }
+        try {
+            for (var _c = __values(e.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), _ = _e[0], item = _e[1];
+                try {
+                    for (var _f = (e_2 = void 0, __values(this.entries())), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
+                        if (v.djangoID === item.djangoID) {
+                            throw new Error('feature state for this feature already exists');
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                    }
+                    finally { if (e_2) throw e_2.error; }
                 }
             }
         }
-        return super.push(...e);
-    }
-}
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return _super.prototype.push.apply(this, __spreadArray([], __read(e), false));
+    };
+    return IdentityFeaturesList;
+}(Array));
 exports.IdentityFeaturesList = IdentityFeaturesList;

package/build/flagsmith-engine/utils/errors.js

@@ -1,6 +1,26 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeatureStateNotFound = void 0;
-class FeatureStateNotFound extends Error {
-}
+var FeatureStateNotFound = /** @class */ (function (_super) {
+    __extends(FeatureStateNotFound, _super);
+    function FeatureStateNotFound() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return FeatureStateNotFound;
+}(Error));
 exports.FeatureStateNotFound = FeatureStateNotFound;

package/build/flagsmith-engine/utils/hashing/index.js

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHashedPercentateForObjIds = void 0;
-const md5_1 = __importDefault(require("md5"));
-const big_integer_1 = __importDefault(require("big-integer"));
-const makeRepeated = (arr, repeats) => Array.from({ length: repeats }, () => arr).flat();
+var md5_1 = __importDefault(require("md5"));
+var big_integer_1 = __importDefault(require("big-integer"));
+var makeRepeated = function (arr, repeats) {
+    return Array.from({ length: repeats }, function () { return arr; }).flat();
+};
 // https://stackoverflow.com/questions/12532871/how-to-convert-a-very-large-hex-number-to-decimal-in-javascript
 function h2d(s) {
     function add(x, y) {
@@ -41,11 +43,12 @@ function h2d(s) {
  * @param  {} iterations=1 num times to include each id in the generated string to hash
  * @returns number number between 0 (inclusive) and 100 (exclusive)
  */
-function getHashedPercentateForObjIds(objectIds, iterations = 1) {
-    let to_hash = makeRepeated(objectIds, iterations).join(',');
-    const hashedValue = (0, md5_1.default)(to_hash);
-    const hashedInt = (0, big_integer_1.default)(h2d(hashedValue));
-    const value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
+function getHashedPercentateForObjIds(objectIds, iterations) {
+    if (iterations === void 0) { iterations = 1; }
+    var to_hash = makeRepeated(objectIds, iterations).join(',');
+    var hashedValue = (0, md5_1.default)(to_hash);
+    var hashedInt = (0, big_integer_1.default)(h2d(hashedValue));
+    var value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
     if (value === 100) {
         return getHashedPercentateForObjIds(objectIds, iterations + 1);
     }

package/build/flagsmith-engine/utils/index.js

@@ -4,11 +4,11 @@ exports.getCastingFunction = void 0;
 function getCastingFunction(input) {
     switch (typeof input) {
         case 'boolean':
-            return (x) => !['False', 'false'].includes(x);
+            return function (x) { return !['False', 'false'].includes(x); };
         case 'number':
-            return (x) => parseFloat(x);
+            return function (x) { return parseFloat(x); };
         default:
-            return (x) => String(x);
+            return function (x) { return String(x); };
     }
 }
 exports.getCastingFunction = getCastingFunction;

package/build/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flagsmith = void 0;
-const sdk_1 = __importDefault(require("./sdk"));
+var sdk_1 = __importDefault(require("./sdk"));
 var sdk_2 = require("./sdk");
 Object.defineProperty(exports, "Flagsmith", { enumerable: true, get: function () { return sdk_2.Flagsmith; } });
 // export default Flagsmith;

package/build/sdk/analytics.js

@@ -1,20 +1,51 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalyticsProcessor = void 0;
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const ANALYTICS_ENDPOINT = 'analytics/flags/';
+var node_fetch_1 = __importDefault(require("node-fetch"));
+var ANALYTICS_ENDPOINT = 'analytics/flags/';
 // Used to control how often we send data(in seconds)
-const ANALYTICS_TIMER = 10;
-const delay = (ms) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
-class AnalyticsProcessor {
-    analyticsEndpoint;
-    environmentKey;
-    lastFlushed;
-    analyticsData;
-    timeout = 3;
+var ANALYTICS_TIMER = 10;
+var delay = function (ms) { return new Promise(function (resolve) { return setTimeout(function () { return resolve(undefined); }, ms); }); };
+var AnalyticsProcessor = /** @class */ (function () {
     /**
      * AnalyticsProcessor is used to track how often individual Flags are evaluated within
      * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
@@ -24,7 +55,8 @@ class AnalyticsProcessor {
      * @param data.timeout used to tell requests to stop waiting for a response after a
             given number of seconds
      */
-    constructor(data) {
+    function AnalyticsProcessor(data) {
+        this.timeout = 3;
         this.analyticsEndpoint = data.baseApiUrl + ANALYTICS_ENDPOINT;
         this.environmentKey = data.environmentKey;
         this.lastFlushed = Date.now();
@@ -34,27 +66,38 @@ class AnalyticsProcessor {
     /**
      * Sends all the collected data to the api asynchronously and resets the timer
      */
-    async flush() {
-        if (!Object.keys(this.analyticsData).length) {
-            return;
-        }
-        await (0, node_fetch_1.default)(this.analyticsEndpoint, {
-            method: 'POST',
-            body: JSON.stringify(this.analyticsData),
-            timeout: this.timeout,
-            headers: {
-                'Content-Type': 'application/json',
-                'X-Environment-Key': this.environmentKey
-            }
+    AnalyticsProcessor.prototype.flush = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!Object.keys(this.analyticsData).length) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, (0, node_fetch_1.default)(this.analyticsEndpoint, {
+                                method: 'POST',
+                                body: JSON.stringify(this.analyticsData),
+                                timeout: this.timeout,
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                    'X-Environment-Key': this.environmentKey
+                                }
+                            })];
+                    case 1:
+                        _a.sent();
+                        this.analyticsData = {};
+                        this.lastFlushed = Date.now();
+                        return [2 /*return*/];
+                }
+            });
         });
-        this.analyticsData = {};
-        this.lastFlushed = Date.now();
-    }
-    trackFeature(featureId) {
+    };
+    AnalyticsProcessor.prototype.trackFeature = function (featureId) {
         this.analyticsData[featureId] = (this.analyticsData[featureId] || 0) + 1;
         if (Date.now() - this.lastFlushed > ANALYTICS_TIMER * 1000) {
             this.flush();
         }
-    }
-}
+    };
+    return AnalyticsProcessor;
+}());
 exports.AnalyticsProcessor = AnalyticsProcessor;