flagsmith-nodejs 2.0.1 → 2.0.4

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganisationModel = void 0;
+var OrganisationModel = /** @class */ (function () {
+    function OrganisationModel(id, name, featureAnalytics, stopServingFlags, persistTraitData) {
+        this.id = id;
+        this.name = name;
+        this.featureAnalytics = featureAnalytics;
+        this.stopServingFlags = stopServingFlags;
+        this.persistTraitData = persistTraitData;
+    }
+    Object.defineProperty(OrganisationModel.prototype, "uniqueSlug", {
+        get: function () {
+            return this.id.toString() + '-' + this.name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return OrganisationModel;
+}());
+exports.OrganisationModel = OrganisationModel;

package/build/flagsmith-engine/organisations/util.d.ts

@@ -0,0 +1,2 @@
+import { OrganisationModel } from './models';
+export declare function buildOrganizationModel(organizationJSON: any): OrganisationModel;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOrganizationModel = void 0;
+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);
+}
+exports.buildOrganizationModel = buildOrganizationModel;

package/build/flagsmith-engine/projects/models.d.ts

@@ -0,0 +1,10 @@
+import { OrganisationModel } from '../organisations/models';
+import { SegmentModel } from '../segments/models';
+export declare class ProjectModel {
+    id: number;
+    name: string;
+    organisation: OrganisationModel;
+    hideDisabledFlags: boolean;
+    segments: SegmentModel[];
+    constructor(id: number, name: string, hideDisabledFlags: boolean, organization: OrganisationModel);
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectModel = void 0;
+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.d.ts

@@ -0,0 +1,2 @@
+import { ProjectModel } from './models';
+export declare function buildProjectModel(projectJSON: any): ProjectModel;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectModel = void 0;
+var util_1 = require("../organisations/util");
+var util_2 = require("../segments/util");
+var models_1 = require("./models");
+function buildProjectModel(projectJSON) {
+    var segments = projectJSON['segments']
+        ? projectJSON['segments'].map(function (s) { return (0, util_2.buildSegmentModel)(s); })
+        : [];
+    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;
+}
+exports.buildProjectModel = buildProjectModel;

package/build/flagsmith-engine/segments/constants.d.ts

@@ -0,0 +1,26 @@
+export declare const ALL_RULE = "ALL";
+export declare const ANY_RULE = "ANY";
+export declare const NONE_RULE = "NONE";
+export declare const RULE_TYPES: string[];
+export declare const EQUAL = "EQUAL";
+export declare const GREATER_THAN = "GREATER_THAN";
+export declare const LESS_THAN = "LESS_THAN";
+export declare const LESS_THAN_INCLUSIVE = "LESS_THAN_INCLUSIVE";
+export declare const CONTAINS = "CONTAINS";
+export declare const GREATER_THAN_INCLUSIVE = "GREATER_THAN_INCLUSIVE";
+export declare const NOT_CONTAINS = "NOT_CONTAINS";
+export declare const NOT_EQUAL = "NOT_EQUAL";
+export declare const REGEX = "REGEX";
+export declare const PERCENTAGE_SPLIT = "PERCENTAGE_SPLIT";
+export declare const CONDITION_OPERATORS: {
+    EQUAL: string;
+    GREATER_THAN: string;
+    LESS_THAN: string;
+    LESS_THAN_INCLUSIVE: string;
+    CONTAINS: string;
+    GREATER_THAN_INCLUSIVE: string;
+    NOT_CONTAINS: string;
+    NOT_EQUAL: string;
+    REGEX: string;
+    PERCENTAGE_SPLIT: string;
+};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONDITION_OPERATORS = exports.PERCENTAGE_SPLIT = exports.REGEX = exports.NOT_EQUAL = exports.NOT_CONTAINS = exports.GREATER_THAN_INCLUSIVE = exports.CONTAINS = exports.LESS_THAN_INCLUSIVE = exports.LESS_THAN = exports.GREATER_THAN = exports.EQUAL = exports.RULE_TYPES = exports.NONE_RULE = exports.ANY_RULE = exports.ALL_RULE = void 0;
+// Segment Rules
+exports.ALL_RULE = 'ALL';
+exports.ANY_RULE = 'ANY';
+exports.NONE_RULE = 'NONE';
+exports.RULE_TYPES = [exports.ALL_RULE, exports.ANY_RULE, exports.NONE_RULE];
+// Segment Condition Operators
+exports.EQUAL = 'EQUAL';
+exports.GREATER_THAN = 'GREATER_THAN';
+exports.LESS_THAN = 'LESS_THAN';
+exports.LESS_THAN_INCLUSIVE = 'LESS_THAN_INCLUSIVE';
+exports.CONTAINS = 'CONTAINS';
+exports.GREATER_THAN_INCLUSIVE = 'GREATER_THAN_INCLUSIVE';
+exports.NOT_CONTAINS = 'NOT_CONTAINS';
+exports.NOT_EQUAL = 'NOT_EQUAL';
+exports.REGEX = 'REGEX';
+exports.PERCENTAGE_SPLIT = 'PERCENTAGE_SPLIT';
+exports.CONDITION_OPERATORS = {
+    EQUAL: exports.EQUAL,
+    GREATER_THAN: exports.GREATER_THAN,
+    LESS_THAN: exports.LESS_THAN,
+    LESS_THAN_INCLUSIVE: exports.LESS_THAN_INCLUSIVE,
+    CONTAINS: exports.CONTAINS,
+    GREATER_THAN_INCLUSIVE: exports.GREATER_THAN_INCLUSIVE,
+    NOT_CONTAINS: exports.NOT_CONTAINS,
+    NOT_EQUAL: exports.NOT_EQUAL,
+    REGEX: exports.REGEX,
+    PERCENTAGE_SPLIT: exports.PERCENTAGE_SPLIT
+};

package/build/flagsmith-engine/segments/evaluators.d.ts

@@ -0,0 +1,6 @@
+import { EnvironmentModel } from '../environments/models';
+import { IdentityModel } from '../identities/models';
+import { TraitModel } from '../identities/traits/models';
+import { SegmentModel } from './models';
+export declare function getIdentitySegments(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): SegmentModel[];
+export declare function evaluateIdentityInSegment(identity: IdentityModel, segment: SegmentModel, overrideTraits?: TraitModel[]): boolean;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateIdentityInSegment = exports.getIdentitySegments = void 0;
+var hashing_1 = require("../utils/hashing");
+var constants_1 = require("./constants");
+function getIdentitySegments(environment, identity, 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(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) {
+    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(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);
+    }
+    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.d.ts

@@ -0,0 +1,37 @@
+import { FeatureStateModel } from '../features/models';
+export declare const all: (iterable: Array<any>) => boolean;
+export declare const any: (iterable: Array<any>) => boolean;
+export declare const matchingFunctions: {
+    [x: string]: (thisValue: any, otherValue: any) => any;
+};
+export declare const semverMatchingFunction: {
+    [x: string]: ((thisValue: any, otherValue: any) => any) | ((thisValue: any, otherValue: any) => boolean);
+};
+export declare const getMatchingFunctions: (semver: boolean) => {
+    [x: string]: (thisValue: any, otherValue: any) => any;
+};
+export declare class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS: {
+        [key: string]: string;
+    };
+    operator: string;
+    value: string;
+    property_: string | undefined;
+    constructor(operator: string, value: string, property?: string);
+    matchesTraitValue(traitValue: any): any;
+}
+export declare class SegmentRuleModel {
+    type: string;
+    rules: SegmentRuleModel[];
+    conditions: SegmentConditionModel[];
+    constructor(type: string);
+    static none(iterable: Array<any>): boolean;
+    matchingFunction(): CallableFunction;
+}
+export declare class SegmentModel {
+    id: number;
+    name: string;
+    rules: SegmentRuleModel[];
+    featureStates: FeatureStateModel[];
+    constructor(id: number, name: string);
+}

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

@@ -0,0 +1,114 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentModel = exports.SegmentRuleModel = exports.SegmentConditionModel = exports.getMatchingFunctions = exports.semverMatchingFunction = exports.matchingFunctions = exports.any = exports.all = void 0;
+var semver_1 = __importDefault(require("semver"));
+var utils_1 = require("../utils");
+var constants_1 = require("./constants");
+var util_1 = require("./util");
+var all = function (iterable) { return iterable.filter(function (e) { return !!e; }).length === iterable.length; };
+exports.all = all;
+var any = function (iterable) { return iterable.filter(function (e) { return !!e; }).length > 0; };
+exports.any = any;
+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);
+exports.semverMatchingFunction = __assign(__assign({}, exports.matchingFunctions), (_b = {}, _b[constants_1.CONDITION_OPERATORS.EQUAL] = function (thisValue, otherValue) { return semver_1.default.eq(thisValue, otherValue); }, _b[constants_1.CONDITION_OPERATORS.GREATER_THAN] = function (thisValue, otherValue) { return semver_1.default.gt(otherValue, thisValue); }, _b[constants_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE] = function (thisValue, otherValue) {
+    return semver_1.default.gte(otherValue, thisValue);
+}, _b[constants_1.CONDITION_OPERATORS.LESS_THAN] = function (thisValue, otherValue) { return semver_1.default.gt(thisValue, otherValue); }, _b[constants_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE] = function (thisValue, otherValue) {
+    return semver_1.default.gte(thisValue, otherValue);
+}, _b));
+var getMatchingFunctions = function (semver) { return (semver ? exports.semverMatchingFunction : exports.matchingFunctions); };
+exports.getMatchingFunctions = getMatchingFunctions;
+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;
+    }
+    SegmentConditionModel.prototype.matchesTraitValue = function (traitValue) {
+        var _this = this;
+        var evaluators = {
+            evaluateNotContains: function (traitValue) {
+                return !traitValue.includes(_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]) {
+            var evaluatorFunction = evaluators[this.EXCEPTION_OPERATOR_METHODS[this.operator]];
+            return evaluatorFunction(traitValue);
+        }
+        var defaultFunction = function (x, y) { return false; };
+        var matchingFunctionSet = (0, exports.getMatchingFunctions)((0, util_1.isSemver)(this.value));
+        var matchingFunction = matchingFunctionSet[this.operator] || defaultFunction;
+        var traitType = (0, util_1.isSemver)(this.value) ? 'semver' : typeof traitValue;
+        var castToTypeOfTraitValue = (0, utils_1.getCastingFunction)(traitType);
+        return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
+    };
+    return SegmentConditionModel;
+}());
+exports.SegmentConditionModel = SegmentConditionModel;
+var SegmentRuleModel = /** @class */ (function () {
+    function SegmentRuleModel(type) {
+        this.rules = [];
+        this.conditions = [];
+        this.type = 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;
+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.d.ts

@@ -0,0 +1,6 @@
+import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models';
+export declare function buildSegmentConditionModel(segmentConditionJSON: any): SegmentConditionModel;
+export declare function buildSegmentRuleModel(ruleModelJSON: any): SegmentRuleModel;
+export declare function buildSegmentModel(segmentModelJSON: any): SegmentModel;
+export declare function isSemver(value: any): boolean;
+export declare function removeSemverSuffix(value: string): string;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSemverSuffix = exports.isSemver = exports.buildSegmentModel = exports.buildSegmentRuleModel = exports.buildSegmentConditionModel = void 0;
+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) {
+    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) {
+    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;
+function isSemver(value) {
+    return typeof value == 'string' && value.endsWith(':semver');
+}
+exports.isSemver = isSemver;
+function removeSemverSuffix(value) {
+    return value.replace(':semver', '');
+}
+exports.removeSemverSuffix = removeSemverSuffix;

package/build/flagsmith-engine/utils/collections.d.ts

@@ -0,0 +1,3 @@
+import { FeatureStateModel } from '../features/models';
+export declare class IdentityFeaturesList extends Array<FeatureStateModel> {
+}

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

@@ -0,0 +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.IdentityFeaturesList = void 0;
+var IdentityFeaturesList = /** @class */ (function (_super) {
+    __extends(IdentityFeaturesList, _super);
+    function IdentityFeaturesList() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return IdentityFeaturesList;
+}(Array));
+exports.IdentityFeaturesList = IdentityFeaturesList;

package/build/flagsmith-engine/utils/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class FeatureStateNotFound extends Error {
+}

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

@@ -0,0 +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;
+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.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @param  {} iterations=1 num times to include each id in the generated string to hash
+ * @returns number number between 0 (inclusive) and 100 (exclusive)
+ */
+export declare function getHashedPercentateForObjIds(objectIds: Array<any>, iterations?: number): number;

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

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHashedPercentateForObjIds = void 0;
+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) {
+        var c = 0, r = [];
+        var x = x.split('').map(Number);
+        var y = y.split('').map(Number);
+        while (x.length || y.length) {
+            var s = (x.pop() || 0) + (y.pop() || 0) + c;
+            r.unshift(s < 10 ? s : s - 10);
+            c = s < 10 ? 0 : 1;
+        }
+        if (c)
+            r.unshift(c);
+        return r.join('');
+    }
+    var dec = '0';
+    s.split('').forEach(function (chr) {
+        var n = parseInt(chr, 16);
+        for (var t = 8; t; t >>= 1) {
+            dec = add(dec, dec);
+            if (n & t)
+                dec = add(dec, '1');
+        }
+    });
+    return dec;
+}
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @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) {
+    if (iterations === void 0) { iterations = 1; }
+    var toHash = makeRepeated(objectIds, iterations).join(',');
+    var hashedValue = (0, md5_1.default)(toHash);
+    var hashedInt = (0, big_integer_1.default)(h2d(hashedValue));
+    var value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
+    if (value === 100) {
+        /* istanbul ignore next */
+        return getHashedPercentateForObjIds(objectIds, iterations + 1);
+    }
+    return value;
+}
+exports.getHashedPercentateForObjIds = getHashedPercentateForObjIds;

package/build/flagsmith-engine/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function getCastingFunction(traitType: 'boolean' | 'string' | 'number' | 'semver' | any): CallableFunction;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCastingFunction = void 0;
+var util_1 = require("../segments/util");
+function getCastingFunction(traitType) {
+    switch (traitType) {
+        case 'boolean':
+            return function (x) { return !['False', 'false'].includes(x); };
+        case 'number':
+            return function (x) { return parseFloat(x); };
+        case 'semver':
+            return function (x) { return (0, util_1.removeSemverSuffix)(x); };
+        default:
+            return function (x) { return String(x); };
+    }
+}
+exports.getCastingFunction = getCastingFunction;

package/build/index.d.ts

@@ -0,0 +1 @@
+export { Flagsmith } from './sdk';

package/build/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flagsmith = void 0;
+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;
+module.exports = sdk_1.default;

package/build/sdk/analytics.d.ts

@@ -0,0 +1,28 @@
+export declare class AnalyticsProcessor {
+    private analyticsEndpoint;
+    private environmentKey;
+    private lastFlushed;
+    analyticsData: {
+        [key: string]: any;
+    };
+    private timeout;
+    /**
+     * AnalyticsProcessor is used to track how often individual Flags are evaluated within
+     * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
+     *
+     * @param data.environmentKey environment key obtained from the Flagsmith UI
+     * @param data.baseApiUrl base api url to override when using self hosted version
+     * @param data.timeout used to tell requests to stop waiting for a response after a
+            given number of seconds
+     */
+    constructor(data: {
+        environmentKey: string;
+        baseApiUrl: string;
+        timeout?: number;
+    });
+    /**
+     * Sends all the collected data to the api asynchronously and resets the timer
+     */
+    flush(): Promise<void>;
+    trackFeature(featureName: string): void;
+}