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

package/.idea/flagsmith-nodejs-client.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/flagsmith-nodejs-client.iml" filepath="$PROJECT_DIR$/.idea/flagsmith-nodejs-client.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

package/build/flagsmith-engine/environments/integrations/models.d.ts

@@ -0,0 +1,4 @@
+export declare class IntegrationModel {
+    api_key?: string;
+    base_url?: string;
+}

package/build/flagsmith-engine/environments/integrations/models.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationModel = void 0;
+var IntegrationModel = /** @class */ (function () {
+    function IntegrationModel() {
+        this.api_key = undefined;
+        this.base_url = undefined;
+    }
+    return IntegrationModel;
+}());
+exports.IntegrationModel = IntegrationModel;

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

@@ -0,0 +1,25 @@
+import { FeatureStateModel } from '../features/models';
+import { ProjectModel } from '../projects/models';
+import { IntegrationModel } from './integrations/models';
+export declare class EnvironmentAPIKeyModel {
+    id: number;
+    key: string;
+    createdAt: number;
+    name: string;
+    clientApiKey: string;
+    expiresAt?: number;
+    active: boolean;
+    constructor(id: number, key: string, createdAt: number, name: string, clientApiKey: string, expiresAt?: number);
+    isValid(): boolean;
+}
+export declare class EnvironmentModel {
+    id: number;
+    apiKey: string;
+    project: ProjectModel;
+    featureStates: FeatureStateModel[];
+    amplitude_config?: IntegrationModel;
+    segment_config?: IntegrationModel;
+    mixpanel_config?: IntegrationModel;
+    heap_config?: IntegrationModel;
+    constructor(id: number, apiKey: string, project: ProjectModel);
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentModel = exports.EnvironmentAPIKeyModel = void 0;
+var EnvironmentAPIKeyModel = /** @class */ (function () {
+    function EnvironmentAPIKeyModel(id, key, createdAt, name, clientApiKey, expiresAt) {
+        this.active = true;
+        this.id = id;
+        this.key = key;
+        this.createdAt = createdAt;
+        this.name = name;
+        this.clientApiKey = clientApiKey;
+        this.expiresAt = expiresAt;
+    }
+    EnvironmentAPIKeyModel.prototype.isValid = function () {
+        return !!this.active && (!this.expiresAt || this.expiresAt > Date.now());
+    };
+    return EnvironmentAPIKeyModel;
+}());
+exports.EnvironmentAPIKeyModel = EnvironmentAPIKeyModel;
+var EnvironmentModel = /** @class */ (function () {
+    function EnvironmentModel(id, apiKey, project) {
+        this.featureStates = [];
+        this.id = id;
+        this.apiKey = apiKey;
+        this.project = project;
+    }
+    return EnvironmentModel;
+}());
+exports.EnvironmentModel = EnvironmentModel;

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

@@ -0,0 +1,3 @@
+import { EnvironmentAPIKeyModel, EnvironmentModel } from './models';
+export declare function buildEnvironmentModel(environmentJSON: any): EnvironmentModel;
+export declare function buildEnvironmentAPIKeyModel(apiKeyJSON: any): EnvironmentAPIKeyModel;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnvironmentAPIKeyModel = exports.buildEnvironmentModel = void 0;
+var util_1 = require("../features/util");
+var util_2 = require("../projects/util");
+var models_1 = require("./models");
+function buildEnvironmentModel(environmentJSON) {
+    var project = (0, util_2.buildProjectModel)(environmentJSON.project);
+    var featureStates = environmentJSON.feature_states.map(function (fs) {
+        return (0, util_1.buildFeatureStateModel)(fs);
+    });
+    var environmentModel = new models_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
+    environmentModel.featureStates = featureStates;
+    return environmentModel;
+}
+exports.buildEnvironmentModel = buildEnvironmentModel;
+function buildEnvironmentAPIKeyModel(apiKeyJSON) {
+    var model = new models_1.EnvironmentAPIKeyModel(apiKeyJSON.id, apiKeyJSON.key, Date.parse(apiKeyJSON.created_at), apiKeyJSON.name, apiKeyJSON.client_api_key);
+    return model;
+}
+exports.buildEnvironmentAPIKeyModel = buildEnvironmentAPIKeyModel;

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

@@ -0,0 +1,4 @@
+export declare const CONSTANTS: {
+    STANDARD: string;
+    MULTIVARIATE: string;
+};

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONSTANTS = void 0;
+exports.CONSTANTS = {
+    STANDARD: 'STANDARD',
+    MULTIVARIATE: 'MULTIVARIATE'
+};

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

@@ -0,0 +1,32 @@
+export declare class FeatureModel {
+    id: number;
+    name: string;
+    type: string;
+    constructor(id: number, name: string, type: string);
+    eq(other: FeatureModel): boolean;
+}
+export declare class MultivariateFeatureOptionModel {
+    value: any;
+    id: number | undefined;
+    constructor(value: any, id?: number);
+}
+export declare class MultivariateFeatureStateValueModel {
+    multivariateFeatureOption: MultivariateFeatureOptionModel;
+    percentageAllocation: number;
+    id: number;
+    mvFsValueUuid: string;
+    constructor(multivariate_feature_option: MultivariateFeatureOptionModel, percentage_allocation: number, id: number, mvFsValueUuid?: string);
+}
+export declare class FeatureStateModel {
+    feature: FeatureModel;
+    enabled: boolean;
+    djangoID: number;
+    featurestateUUID: string;
+    private value;
+    multivariateFeatureStateValues: MultivariateFeatureStateValueModel[];
+    constructor(feature: FeatureModel, enabled: boolean, djangoID: number, value?: any, featurestateUuid?: string);
+    setValue(value: any): void;
+    getValue(identityId?: number | string): any;
+    get_feature_state_value(): any;
+    getMultivariateValue(identityID: number | string): any;
+}

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

@@ -0,0 +1,102 @@
+"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.FeatureStateModel = exports.MultivariateFeatureStateValueModel = exports.MultivariateFeatureOptionModel = exports.FeatureModel = void 0;
+var uuid_1 = require("uuid");
+var hashing_1 = require("../utils/hashing");
+var FeatureModel = /** @class */ (function () {
+    function FeatureModel(id, name, type) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+    }
+    FeatureModel.prototype.eq = function (other) {
+        return !!other && this.id === other.id;
+    };
+    return FeatureModel;
+}());
+exports.FeatureModel = FeatureModel;
+var MultivariateFeatureOptionModel = /** @class */ (function () {
+    function MultivariateFeatureOptionModel(value, id) {
+        this.value = value;
+        this.id = id;
+    }
+    return MultivariateFeatureOptionModel;
+}());
+exports.MultivariateFeatureOptionModel = MultivariateFeatureOptionModel;
+var MultivariateFeatureStateValueModel = /** @class */ (function () {
+    function MultivariateFeatureStateValueModel(multivariate_feature_option, percentage_allocation, id, mvFsValueUuid) {
+        this.mvFsValueUuid = (0, uuid_1.v4)();
+        this.id = id;
+        this.percentageAllocation = percentage_allocation;
+        this.multivariateFeatureOption = multivariate_feature_option;
+        this.mvFsValueUuid = mvFsValueUuid || this.mvFsValueUuid;
+    }
+    return MultivariateFeatureStateValueModel;
+}());
+exports.MultivariateFeatureStateValueModel = MultivariateFeatureStateValueModel;
+var FeatureStateModel = /** @class */ (function () {
+    function FeatureStateModel(feature, enabled, djangoID, value, featurestateUuid) {
+        if (featurestateUuid === void 0) { featurestateUuid = (0, uuid_1.v4)(); }
+        this.featurestateUUID = (0, uuid_1.v4)();
+        this.multivariateFeatureStateValues = [];
+        this.feature = feature;
+        this.enabled = enabled;
+        this.djangoID = djangoID;
+        this.value = value;
+        this.featurestateUUID = featurestateUuid;
+    }
+    FeatureStateModel.prototype.setValue = function (value) {
+        this.value = value;
+    };
+    FeatureStateModel.prototype.getValue = function (identityId) {
+        if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
+            return this.getMultivariateValue(identityId);
+        }
+        return this.value;
+    };
+    FeatureStateModel.prototype.get_feature_state_value = function () {
+        return this.getValue();
+    };
+    FeatureStateModel.prototype.getMultivariateValue = function (identityID) {
+        var e_1, _a;
+        var percentageValue = (0, hashing_1.getHashedPercentateForObjIds)([
+            this.djangoID || this.featurestateUUID,
+            identityID
+        ]);
+        var startPercentage = 0;
+        var sortedF = this.multivariateFeatureStateValues.sort(function (a, b) {
+            return !!(a.id && b.id) ? a.id - b.id : a.mvFsValueUuid > b.mvFsValueUuid ? -1 : 1;
+        });
+        try {
+            for (var sortedF_1 = __values(sortedF), sortedF_1_1 = sortedF_1.next(); !sortedF_1_1.done; sortedF_1_1 = sortedF_1.next()) {
+                var myValue = sortedF_1_1.value;
+                var limit = myValue.percentageAllocation + startPercentage;
+                if (startPercentage <= percentageValue && percentageValue < limit) {
+                    return myValue.multivariateFeatureOption.value;
+                }
+                startPercentage = limit;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (sortedF_1_1 && !sortedF_1_1.done && (_a = sortedF_1.return)) _a.call(sortedF_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return this.value;
+    };
+    return FeatureStateModel;
+}());
+exports.FeatureStateModel = FeatureStateModel;

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

@@ -0,0 +1,3 @@
+import { FeatureModel, FeatureStateModel } from './models';
+export declare function buildFeatureModel(featuresModelJSON: any): FeatureModel;
+export declare function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStateModel;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFeatureStateModel = exports.buildFeatureModel = void 0;
+var models_1 = require("./models");
+function buildFeatureModel(featuresModelJSON) {
+    return new models_1.FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
+}
+exports.buildFeatureModel = buildFeatureModel;
+function buildFeatureStateModel(featuresStateModelJSON) {
+    var featureStateModel = new models_1.FeatureStateModel(buildFeatureModel(featuresStateModelJSON.feature), featuresStateModelJSON.enabled, featuresStateModelJSON.django_id, featuresStateModelJSON.feature_state_value, featuresStateModelJSON.uuid);
+    var multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
+        ? featuresStateModelJSON.multivariate_feature_state_values.map(function (fsv) {
+            var featureOption = new models_1.MultivariateFeatureOptionModel(fsv.multivariate_feature_option.value, fsv.multivariate_feature_option.id);
+            return new models_1.MultivariateFeatureStateValueModel(featureOption, fsv.percentage_allocation, fsv.id);
+        })
+        : [];
+    featureStateModel.multivariateFeatureStateValues = multivariateFeatureStateValues;
+    return featureStateModel;
+}
+exports.buildFeatureStateModel = buildFeatureStateModel;

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

@@ -0,0 +1,15 @@
+import { IdentityFeaturesList } from '../utils/collections';
+import { TraitModel } from './traits/models';
+export declare class IdentityModel {
+    identifier: string;
+    environmentApiKey: string;
+    createdDate?: number;
+    identityFeatures: IdentityFeaturesList;
+    identityTraits: TraitModel[];
+    identityUuid: string;
+    djangoID: number | undefined;
+    constructor(created_date: string, identityTraits: TraitModel[], identityFeatures: IdentityFeaturesList, environmentApiKey: string, identifier: string, identityUuid?: string);
+    get compositeKey(): string;
+    static generateCompositeKey(env_key: string, identifier: string): string;
+    update_traits(traits: TraitModel[]): void;
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+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));
+};
+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.IdentityModel = void 0;
+var collections_1 = require("../utils/collections");
+var uuidv4 = require('uuid').v4;
+var IdentityModel = /** @class */ (function () {
+    function IdentityModel(created_date, identityTraits, identityFeatures, environmentApiKey, identifier, identityUuid) {
+        this.identityUuid = identityUuid || uuidv4();
+        this.createdDate = Date.parse(created_date) || Date.now();
+        this.identityTraits = identityTraits;
+        this.identityFeatures = new (collections_1.IdentityFeaturesList.bind.apply(collections_1.IdentityFeaturesList, __spreadArray([void 0], __read(identityFeatures), false)))();
+        this.environmentApiKey = environmentApiKey;
+        this.identifier = identifier;
+    }
+    Object.defineProperty(IdentityModel.prototype, "compositeKey", {
+        get: function () {
+            return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IdentityModel.generateCompositeKey = function (env_key, identifier) {
+        return "".concat(env_key, "_").concat(identifier);
+    };
+    IdentityModel.prototype.update_traits = function (traits) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        var existingTraits = new Map();
+        try {
+            for (var _d = __values(this.identityTraits), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var trait = _e.value;
+                existingTraits.set(trait.traitKey, trait);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var traits_1 = __values(traits), traits_1_1 = traits_1.next(); !traits_1_1.done; traits_1_1 = traits_1.next()) {
+                var trait = traits_1_1.value;
+                if (!!trait.traitValue) {
+                    existingTraits.set(trait.traitKey, trait);
+                }
+                else {
+                    existingTraits.delete(trait.traitKey);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (traits_1_1 && !traits_1_1.done && (_b = traits_1.return)) _b.call(traits_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        this.identityTraits = [];
+        try {
+            for (var _f = __values(existingTraits.entries()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
+                this.identityTraits.push(v);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    return IdentityModel;
+}());
+exports.IdentityModel = IdentityModel;

package/build/flagsmith-engine/identities/traits/models.d.ts

@@ -0,0 +1,5 @@
+export declare class TraitModel {
+    traitKey: string;
+    traitValue: any;
+    constructor(key: string, value: any);
+}

package/build/flagsmith-engine/identities/traits/models.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraitModel = void 0;
+var TraitModel = /** @class */ (function () {
+    function TraitModel(key, value) {
+        this.traitKey = key;
+        this.traitValue = value;
+    }
+    return TraitModel;
+}());
+exports.TraitModel = TraitModel;

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

@@ -0,0 +1,4 @@
+import { IdentityModel } from './models';
+import { TraitModel } from './traits/models';
+export declare function buildTraitModel(traitJSON: any): TraitModel;
+export declare function buildIdentityModel(identityJSON: any): IdentityModel;

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

@@ -0,0 +1,46 @@
+"use strict";
+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.buildIdentityModel = exports.buildTraitModel = void 0;
+var util_1 = require("../features/util");
+var collections_1 = require("../utils/collections");
+var models_1 = require("./models");
+var models_2 = require("./traits/models");
+function buildTraitModel(traitJSON) {
+    return new models_2.TraitModel(traitJSON.trait_key, traitJSON.trait_value);
+}
+exports.buildTraitModel = buildTraitModel;
+function buildIdentityModel(identityJSON) {
+    var featureList = identityJSON.identity_features
+        ? new (collections_1.IdentityFeaturesList.bind.apply(collections_1.IdentityFeaturesList, __spreadArray([void 0], __read(identityJSON.identity_features.map(function (f) { return (0, util_1.buildFeatureStateModel)(f); })), false)))() : [];
+    var model = new models_1.IdentityModel(identityJSON.created_date, identityJSON.identity_traits
+        ? identityJSON.identity_traits.map(function (trait) { return buildTraitModel(trait); })
+        : [], featureList, identityJSON.environment_api_key, identityJSON.identifier, identityJSON.identity_uuid);
+    model.djangoID = identityJSON.django_id;
+    return model;
+}
+exports.buildIdentityModel = buildIdentityModel;

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

@@ -0,0 +1,8 @@
+import { EnvironmentModel } from './environments/models';
+import { FeatureStateModel } from './features/models';
+import { IdentityModel } from './identities/models';
+import { TraitModel } from './identities/traits/models';
+export declare function getIdentityFeatureState(environment: EnvironmentModel, identity: IdentityModel, featureName: string, overrideTraits?: TraitModel[]): FeatureStateModel;
+export declare function getIdentityFeatureStates(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): FeatureStateModel[];
+export declare function getEnvironmentFeatureState(environment: EnvironmentModel, featureName: string): FeatureStateModel;
+export declare function getEnvironmentFeatureStates(environment: EnvironmentModel): FeatureStateModel[];

package/build/flagsmith-engine/index.js

@@ -0,0 +1,113 @@
+"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 = void 0;
+var evaluators_1 = require("./segments/evaluators");
+var errors_1 = require("./utils/errors");
+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;
+                    // note that feature states are stored on the segment in descending priority
+                    // order so we only care that the last one is added
+                    // TODO: can we optimise this?
+                    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 Error('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 unique_slug(): string;
+}