flagsmith-nodejs 3.0.0 → 3.1.0

package/build/flagsmith-engine/index.js

@@ -0,0 +1,129 @@
+"use strict";
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironmentFeatureStates = exports.getEnvironmentFeatureState = exports.getIdentityFeatureStates = exports.getIdentityFeatureState = exports.OrganisationModel = exports.SegmentModel = exports.TraitModel = exports.IdentityModel = exports.FeatureStateModel = exports.IntegrationModel = exports.EnvironmentModel = void 0;
+var evaluators_1 = require("./segments/evaluators");
+var errors_1 = require("./utils/errors");
+var models_1 = require("./environments/models");
+Object.defineProperty(exports, "EnvironmentModel", { enumerable: true, get: function () { return models_1.EnvironmentModel; } });
+var models_2 = require("./environments/integrations/models");
+Object.defineProperty(exports, "IntegrationModel", { enumerable: true, get: function () { return models_2.IntegrationModel; } });
+var models_3 = require("./features/models");
+Object.defineProperty(exports, "FeatureStateModel", { enumerable: true, get: function () { return models_3.FeatureStateModel; } });
+var models_4 = require("./identities/models");
+Object.defineProperty(exports, "IdentityModel", { enumerable: true, get: function () { return models_4.IdentityModel; } });
+var models_5 = require("./identities/traits/models");
+Object.defineProperty(exports, "TraitModel", { enumerable: true, get: function () { return models_5.TraitModel; } });
+var models_6 = require("./segments/models");
+Object.defineProperty(exports, "SegmentModel", { enumerable: true, get: function () { return models_6.SegmentModel; } });
+var models_7 = require("./organisations/models");
+Object.defineProperty(exports, "OrganisationModel", { enumerable: true, get: function () { return models_7.OrganisationModel; } });
+function getIdentityFeatureStatesDict(environment, identity, overrideTraits) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    // Get feature states from the environment
+    var featureStates = {};
+    try {
+        for (var _e = __values(environment.featureStates), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var fs = _f.value;
+            featureStates[fs.feature.id] = fs;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    // Override with any feature states defined by matching segments
+    var identitySegments = (0, evaluators_1.getIdentitySegments)(environment, identity, overrideTraits);
+    try {
+        for (var identitySegments_1 = __values(identitySegments), identitySegments_1_1 = identitySegments_1.next(); !identitySegments_1_1.done; identitySegments_1_1 = identitySegments_1.next()) {
+            var matchingSegment = identitySegments_1_1.value;
+            try {
+                for (var _g = (e_3 = void 0, __values(matchingSegment.featureStates)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var featureState = _h.value;
+                    if (featureStates[featureState.feature.id]) {
+                        if (featureStates[featureState.feature.id].isHigherSegmentPriority(featureState)) {
+                            continue;
+                        }
+                    }
+                    featureStates[featureState.feature.id] = featureState;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (identitySegments_1_1 && !identitySegments_1_1.done && (_b = identitySegments_1.return)) _b.call(identitySegments_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        // Override with any feature states defined directly the identity
+        for (var _j = __values(identity.identityFeatures), _k = _j.next(); !_k.done; _k = _j.next()) {
+            var fs = _k.value;
+            if (featureStates[fs.feature.id]) {
+                featureStates[fs.feature.id] = fs;
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_k && !_k.done && (_d = _j.return)) _d.call(_j);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return featureStates;
+}
+function getIdentityFeatureState(environment, identity, featureName, overrideTraits) {
+    var featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
+    var matchingFeature = Object.values(featureStates).filter(function (f) { return f.feature.name === featureName; });
+    if (matchingFeature.length === 0) {
+        throw new errors_1.FeatureStateNotFound('Feature State Not Found');
+    }
+    return matchingFeature[0];
+}
+exports.getIdentityFeatureState = getIdentityFeatureState;
+function getIdentityFeatureStates(environment, identity, overrideTraits) {
+    var featureStates = Object.values(getIdentityFeatureStatesDict(environment, identity, overrideTraits));
+    if (environment.project.hideDisabledFlags) {
+        return featureStates.filter(function (fs) { return !!fs.enabled; });
+    }
+    return featureStates;
+}
+exports.getIdentityFeatureStates = getIdentityFeatureStates;
+function getEnvironmentFeatureState(environment, featureName) {
+    var featuresStates = environment.featureStates.filter(function (f) { return f.feature.name === featureName; });
+    if (featuresStates.length === 0) {
+        throw new errors_1.FeatureStateNotFound('Feature State Not Found');
+    }
+    return featuresStates[0];
+}
+exports.getEnvironmentFeatureState = getEnvironmentFeatureState;
+function getEnvironmentFeatureStates(environment) {
+    if (environment.project.hideDisabledFlags) {
+        return environment.featureStates.filter(function (fs) { return !!fs.enabled; });
+    }
+    return environment.featureStates;
+}
+exports.getEnvironmentFeatureStates = getEnvironmentFeatureStates;

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

@@ -0,0 +1,9 @@
+export declare class OrganisationModel {
+    id: number;
+    name: string;
+    featureAnalytics: boolean;
+    stopServingFlags: boolean;
+    persistTraitData: boolean;
+    constructor(id: number, name: string, featureAnalytics: boolean, stopServingFlags: boolean, persistTraitData: boolean);
+    get uniqueSlug(): string;
+}

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,34 @@
+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 IS_SET = "IS_SET";
+export declare const IS_NOT_SET = "IS_NOT_SET";
+export declare const MODULO = "MODULO";
+export declare const IN = "IN";
+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;
+    IS_SET: string;
+    IS_NOT_SET: string;
+    MODULO: string;
+    IN: string;
+};

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONDITION_OPERATORS = exports.IN = exports.MODULO = exports.IS_NOT_SET = exports.IS_SET = 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.IS_SET = 'IS_SET';
+exports.IS_NOT_SET = 'IS_NOT_SET';
+exports.MODULO = 'MODULO';
+exports.IN = 'IN';
+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,
+    IS_SET: exports.IS_SET,
+    IS_NOT_SET: exports.IS_NOT_SET,
+    MODULO: exports.MODULO,
+    IN: exports.IN
+};

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

@@ -0,0 +1,7 @@
+import { EnvironmentModel } from '../environments/models';
+import { IdentityModel } from '../identities/models';
+import { TraitModel } from '../identities/traits/models';
+import { SegmentConditionModel, 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;
+export declare function traitsMatchSegmentCondition(identityTraits: TraitModel[], condition: SegmentConditionModel, segmentId: number | string, identityId: number | string): boolean;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traitsMatchSegmentCondition = 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.djangoID || 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) {
+        var hashedPercentage = (0, hashing_1.getHashedPercentateForObjIds)([segmentId, identityId]);
+        return hashedPercentage <= parseFloat(String(condition.value));
+    }
+    var traits = identityTraits.filter(function (t) { return t.traitKey === condition.property_; });
+    var trait = traits.length > 0 ? traits[0] : undefined;
+    if (condition.operator === constants_1.IS_SET) {
+        return !!trait;
+    }
+    else if (condition.operator === constants_1.IS_NOT_SET) {
+        return trait == undefined;
+    }
+    return trait ? condition.matchesTraitValue(trait.traitValue) : false;
+}
+exports.traitsMatchSegmentCondition = traitsMatchSegmentCondition;

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 | null | undefined;
+    property_: string | null | undefined;
+    constructor(operator: string, value?: string | null | undefined, property?: string | null | undefined);
+    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,144 @@
+"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 __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 __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[constants_1.MODULO] = 'evaluateModulo',
+            _a[constants_1.IN] = 'evaluateIn',
+            _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 !!_this.value && !!traitValue.match(new RegExp(_this.value));
+            },
+            evaluateModulo: function (traitValue) {
+                if (isNaN(parseFloat(traitValue)) || !_this.value) {
+                    return false;
+                }
+                var parts = (_this.value).split("|");
+                var _a = __read([parseFloat(parts[0]), parseFloat(parts[1])], 2), divisor = _a[0], reminder = _a[1];
+                return traitValue % divisor === reminder;
+            },
+            evaluateIn: function (traitValue) {
+                var _a;
+                return (_a = _this.value) === null || _a === void 0 ? void 0 : _a.split(',').includes(traitValue.toString());
+            },
+        };
+        // 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;