flagsmith-nodejs 3.3.3 → 4.0.0

package/.github/workflows/publish.yml

@@ -14,9 +14,9 @@ jobs:
       - name: Cloning repo
         uses: actions/checkout@v3
 
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
-          node-version: '16.x'
+          node-version: '18.x'
           registry-url: 'https://registry.npmjs.org'
 
       - run: npm ci

package/.github/workflows/pull_request.yaml

@@ -14,28 +14,21 @@ jobs:
   build-and-test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - name: Checkout submodules # checkout rest
-        shell: bash
-        run: |
-          # If your submodules are configured to use SSH instead of HTTPS please uncomment the following line
-          git config --global url."https://github.com/".insteadOf "git@github.com:"
-          auth_header="$(git config --local --get http.https://github.com/.extraheader)"
-          git submodule sync --recursive
-          git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
         with:
-          node-version: "15.x"
+          submodules: true
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "18.x"
       - name: cache node modules
-        uses: actions/cache@v1
+        uses: actions/cache@v4
         with:
           path: ~/.npm # npm cache files are stored in `~/.npm` on Linux/macOS
           key: npm-${{ hashFiles('package-lock.json') }}
           restore-keys: |
             npm-${{ hashFiles('package-lock.json') }}
             npm-
-      - run: npm i -g npm@7.0.2
-      - run: npm install
+      - run: npm ci
       - run: npm test
         env:
           CI: true

package/build/{flagsmith-engine → cjs/flagsmith-engine}/environments/models.d.ts

@@ -1,6 +1,6 @@
-import { FeatureStateModel } from '../features/models';
-import { IdentityModel } from '../identities/models';
-import { ProjectModel } from '../projects/models';
+import { FeatureStateModel } from '../features/models.js';
+import { IdentityModel } from '../identities/models.js';
+import { ProjectModel } from '../projects/models.js';
 export declare class EnvironmentAPIKeyModel {
     id: number;
     key: string;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/environments/models.js

@@ -1,9 +1,15 @@
 "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;
+class EnvironmentAPIKeyModel {
+    id;
+    key;
+    createdAt;
+    name;
+    clientApiKey;
+    expiresAt;
+    active = true;
+    constructor(id, key, createdAt, name, clientApiKey, expiresAt) {
         this.id = id;
         this.key = key;
         this.createdAt = createdAt;
@@ -11,20 +17,21 @@ var EnvironmentAPIKeyModel = /** @class */ (function () {
         this.clientApiKey = clientApiKey;
         this.expiresAt = expiresAt;
     }
-    EnvironmentAPIKeyModel.prototype.isValid = function () {
+    isValid() {
         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.identityOverrides = [];
+class EnvironmentModel {
+    id;
+    apiKey;
+    project;
+    featureStates = [];
+    identityOverrides = [];
+    constructor(id, apiKey, project) {
         this.id = id;
         this.apiKey = apiKey;
         this.project = project;
     }
-    return EnvironmentModel;
-}());
+}
 exports.EnvironmentModel = EnvironmentModel;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/environments/util.d.ts

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnvironmentAPIKeyModel = exports.buildEnvironmentModel = void 0;
+const util_js_1 = require("../features/util.js");
+const util_js_2 = require("../identities/util.js");
+const util_js_3 = require("../projects/util.js");
+const models_js_1 = require("./models.js");
+function buildEnvironmentModel(environmentJSON) {
+    const project = (0, util_js_3.buildProjectModel)(environmentJSON.project);
+    const featureStates = environmentJSON.feature_states.map((fs) => (0, util_js_1.buildFeatureStateModel)(fs));
+    const environmentModel = new models_js_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
+    environmentModel.featureStates = featureStates;
+    if (!!environmentJSON.identity_overrides) {
+        environmentModel.identityOverrides = environmentJSON.identity_overrides.map((identityData) => (0, util_js_2.buildIdentityModel)(identityData));
+    }
+    return environmentModel;
+}
+exports.buildEnvironmentModel = buildEnvironmentModel;
+function buildEnvironmentAPIKeyModel(apiKeyJSON) {
+    const model = new models_js_1.EnvironmentAPIKeyModel(apiKeyJSON.id, apiKeyJSON.key, Date.parse(apiKeyJSON.created_at), apiKeyJSON.name, apiKeyJSON.client_api_key);
+    return model;
+}
+exports.buildEnvironmentAPIKeyModel = buildEnvironmentAPIKeyModel;

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureSegment = exports.FeatureStateModel = exports.MultivariateFeatureStateValueModel = exports.MultivariateFeatureOptionModel = exports.FeatureModel = void 0;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../utils/hashing/index.js");
+class FeatureModel {
+    id;
+    name;
+    type;
+    constructor(id, name, type) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+    }
+    eq(other) {
+        return !!other && this.id === other.id;
+    }
+}
+exports.FeatureModel = FeatureModel;
+class MultivariateFeatureOptionModel {
+    value;
+    id;
+    constructor(value, id) {
+        this.value = value;
+        this.id = id;
+    }
+}
+exports.MultivariateFeatureOptionModel = MultivariateFeatureOptionModel;
+class MultivariateFeatureStateValueModel {
+    multivariateFeatureOption;
+    percentageAllocation;
+    id;
+    mvFsValueUuid = (0, node_crypto_1.randomUUID)();
+    constructor(multivariate_feature_option, percentage_allocation, id, mvFsValueUuid) {
+        this.id = id;
+        this.percentageAllocation = percentage_allocation;
+        this.multivariateFeatureOption = multivariate_feature_option;
+        this.mvFsValueUuid = mvFsValueUuid || this.mvFsValueUuid;
+    }
+}
+exports.MultivariateFeatureStateValueModel = MultivariateFeatureStateValueModel;
+class FeatureStateModel {
+    feature;
+    enabled;
+    djangoID;
+    featurestateUUID = (0, node_crypto_1.randomUUID)();
+    featureSegment;
+    value;
+    multivariateFeatureStateValues = [];
+    constructor(feature, enabled, djangoID, value, featurestateUuid = (0, node_crypto_1.randomUUID)()) {
+        this.feature = feature;
+        this.enabled = enabled;
+        this.djangoID = djangoID;
+        this.value = value;
+        this.featurestateUUID = featurestateUuid;
+    }
+    setValue(value) {
+        this.value = value;
+    }
+    getValue(identityId) {
+        if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
+            return this.getMultivariateValue(identityId);
+        }
+        return this.value;
+    }
+    /*
+        Returns `True` if `this` is higher segment priority than `other`
+        (i.e. has lower value for featureSegment.priority)
+        NOTE:
+            A segment will be considered higher priority only if:
+            1. `other` does not have a feature segment(i.e: it is an environment feature state or it's a
+            feature state with feature segment but from an old document that does not have `featureSegment.priority`)
+            but `this` does.
+            2. `other` have a feature segment with high priority
+    */
+    isHigherSegmentPriority(other) {
+        if (!other.featureSegment || !this.featureSegment) {
+            return !!this.featureSegment && !other.featureSegment;
+        }
+        return this.featureSegment.priority < other.featureSegment.priority;
+    }
+    getMultivariateValue(identityID) {
+        let percentageValue;
+        let startPercentage = 0;
+        const sortedF = this.multivariateFeatureStateValues.sort((a, b) => {
+            return a.id - b.id;
+        });
+        for (const myValue of sortedF) {
+            switch (myValue.percentageAllocation) {
+                case 0:
+                    continue;
+                case 100:
+                    return myValue.multivariateFeatureOption.value;
+                default:
+                    if (percentageValue === undefined) {
+                        percentageValue = (0, index_js_1.getHashedPercentateForObjIds)([
+                            this.djangoID || this.featurestateUUID,
+                            identityID
+                        ]);
+                    }
+            }
+            const limit = myValue.percentageAllocation + startPercentage;
+            if (startPercentage <= percentageValue && percentageValue < limit) {
+                return myValue.multivariateFeatureOption.value;
+            }
+            startPercentage = limit;
+        }
+        return this.value;
+    }
+}
+exports.FeatureStateModel = FeatureStateModel;
+class FeatureSegment {
+    priority;
+    constructor(priority) {
+        this.priority = priority;
+    }
+}
+exports.FeatureSegment = FeatureSegment;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/features/util.d.ts

@@ -1,4 +1,4 @@
-import { FeatureModel, FeatureSegment, FeatureStateModel } from './models';
+import { FeatureModel, FeatureSegment, FeatureStateModel } from './models.js';
 export declare function buildFeatureModel(featuresModelJSON: any): FeatureModel;
 export declare function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStateModel;
 export declare function buildFeatureSegment(featureSegmentJSON: any): FeatureSegment;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFeatureSegment = exports.buildFeatureStateModel = exports.buildFeatureModel = void 0;
+const models_js_1 = require("./models.js");
+function buildFeatureModel(featuresModelJSON) {
+    return new models_js_1.FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
+}
+exports.buildFeatureModel = buildFeatureModel;
+function buildFeatureStateModel(featuresStateModelJSON) {
+    const featureStateModel = new models_js_1.FeatureStateModel(buildFeatureModel(featuresStateModelJSON.feature), featuresStateModelJSON.enabled, featuresStateModelJSON.django_id, featuresStateModelJSON.feature_state_value, featuresStateModelJSON.featurestate_uuid);
+    featureStateModel.featureSegment = featuresStateModelJSON.feature_segment ?
+        buildFeatureSegment(featuresStateModelJSON.feature_segment) :
+        undefined;
+    const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
+        ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv) => {
+            const featureOption = new models_js_1.MultivariateFeatureOptionModel(fsv.multivariate_feature_option.value, fsv.multivariate_feature_option.id);
+            return new models_js_1.MultivariateFeatureStateValueModel(featureOption, fsv.percentage_allocation, fsv.id, fsv.mv_fs_value_uuid);
+        })
+        : [];
+    featureStateModel.multivariateFeatureStateValues = multivariateFeatureStateValues;
+    return featureStateModel;
+}
+exports.buildFeatureStateModel = buildFeatureStateModel;
+function buildFeatureSegment(featureSegmentJSON) {
+    return new models_js_1.FeatureSegment(featureSegmentJSON.priority);
+}
+exports.buildFeatureSegment = buildFeatureSegment;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/identities/models.d.ts

@@ -1,5 +1,5 @@
-import { IdentityFeaturesList } from '../utils/collections';
-import { TraitModel } from './traits/models';
+import { IdentityFeaturesList } from '../utils/collections.js';
+import { TraitModel } from './traits/models.js';
 export declare class IdentityModel {
     identifier: string;
     environmentApiKey: string;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityModel = void 0;
+const collections_js_1 = require("../utils/collections.js");
+const node_crypto_1 = require("node:crypto");
+class IdentityModel {
+    identifier;
+    environmentApiKey;
+    createdDate;
+    identityFeatures;
+    identityTraits;
+    identityUuid;
+    djangoID;
+    constructor(created_date, identityTraits, identityFeatures, environmentApiKey, identifier, identityUuid, djangoID) {
+        this.identityUuid = identityUuid || (0, node_crypto_1.randomUUID)();
+        this.createdDate = Date.parse(created_date) || Date.now();
+        this.identityTraits = identityTraits;
+        this.identityFeatures = new collections_js_1.IdentityFeaturesList(...identityFeatures);
+        this.environmentApiKey = environmentApiKey;
+        this.identifier = identifier;
+        this.djangoID = djangoID;
+    }
+    get compositeKey() {
+        return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
+    }
+    static generateCompositeKey(env_key, identifier) {
+        return `${env_key}_${identifier}`;
+    }
+    updateTraits(traits) {
+        const existingTraits = new Map();
+        for (const trait of this.identityTraits) {
+            existingTraits.set(trait.traitKey, trait);
+        }
+        for (const trait of traits) {
+            if (!!trait.traitValue) {
+                existingTraits.set(trait.traitKey, trait);
+            }
+            else {
+                existingTraits.delete(trait.traitKey);
+            }
+        }
+        this.identityTraits = [];
+        for (const [k, v] of existingTraits.entries()) {
+            this.identityTraits.push(v);
+        }
+    }
+}
+exports.IdentityModel = IdentityModel;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/identities/traits/models.js

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

package/build/{flagsmith-engine → cjs/flagsmith-engine}/identities/util.d.ts

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIdentityModel = exports.buildTraitModel = void 0;
+const util_js_1 = require("../features/util.js");
+const collections_js_1 = require("../utils/collections.js");
+const models_js_1 = require("./models.js");
+const models_js_2 = require("./traits/models.js");
+function buildTraitModel(traitJSON) {
+    return new models_js_2.TraitModel(traitJSON.trait_key, traitJSON.trait_value);
+}
+exports.buildTraitModel = buildTraitModel;
+function buildIdentityModel(identityJSON) {
+    const featureList = identityJSON.identity_features
+        ? new collections_js_1.IdentityFeaturesList(...identityJSON.identity_features.map((f) => (0, util_js_1.buildFeatureStateModel)(f)))
+        : [];
+    const model = new models_js_1.IdentityModel(identityJSON.created_date, identityJSON.identity_traits
+        ? identityJSON.identity_traits.map((trait) => buildTraitModel(trait))
+        : [], featureList, identityJSON.environment_api_key, identityJSON.identifier, identityJSON.identity_uuid);
+    model.djangoID = identityJSON.django_id;
+    return model;
+}
+exports.buildIdentityModel = buildIdentityModel;

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

@@ -0,0 +1,14 @@
+import { EnvironmentModel } from './environments/models.js';
+import { FeatureStateModel } from './features/models.js';
+import { IdentityModel } from './identities/models.js';
+import { TraitModel } from './identities/traits/models.js';
+export { EnvironmentModel } from './environments/models.js';
+export { FeatureStateModel } from './features/models.js';
+export { IdentityModel } from './identities/models.js';
+export { TraitModel } from './identities/traits/models.js';
+export { SegmentModel } from './segments/models.js';
+export { OrganisationModel } from './organisations/models.js';
+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/cjs/flagsmith-engine/index.js

@@ -0,0 +1,75 @@
+"use strict";
+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.EnvironmentModel = void 0;
+const evaluators_js_1 = require("./segments/evaluators.js");
+const errors_js_1 = require("./utils/errors.js");
+var models_js_1 = require("./environments/models.js");
+Object.defineProperty(exports, "EnvironmentModel", { enumerable: true, get: function () { return models_js_1.EnvironmentModel; } });
+var models_js_2 = require("./features/models.js");
+Object.defineProperty(exports, "FeatureStateModel", { enumerable: true, get: function () { return models_js_2.FeatureStateModel; } });
+var models_js_3 = require("./identities/models.js");
+Object.defineProperty(exports, "IdentityModel", { enumerable: true, get: function () { return models_js_3.IdentityModel; } });
+var models_js_4 = require("./identities/traits/models.js");
+Object.defineProperty(exports, "TraitModel", { enumerable: true, get: function () { return models_js_4.TraitModel; } });
+var models_js_5 = require("./segments/models.js");
+Object.defineProperty(exports, "SegmentModel", { enumerable: true, get: function () { return models_js_5.SegmentModel; } });
+var models_js_6 = require("./organisations/models.js");
+Object.defineProperty(exports, "OrganisationModel", { enumerable: true, get: function () { return models_js_6.OrganisationModel; } });
+function getIdentityFeatureStatesDict(environment, identity, overrideTraits) {
+    // Get feature states from the environment
+    const featureStates = {};
+    for (const fs of environment.featureStates) {
+        featureStates[fs.feature.id] = fs;
+    }
+    // Override with any feature states defined by matching segments
+    const identitySegments = (0, evaluators_js_1.getIdentitySegments)(environment, identity, overrideTraits);
+    for (const matchingSegment of identitySegments) {
+        for (const featureState of matchingSegment.featureStates) {
+            if (featureStates[featureState.feature.id]) {
+                if (featureStates[featureState.feature.id].isHigherSegmentPriority(featureState)) {
+                    continue;
+                }
+            }
+            featureStates[featureState.feature.id] = featureState;
+        }
+    }
+    // Override with any feature states defined directly the identity
+    for (const fs of identity.identityFeatures) {
+        if (featureStates[fs.feature.id]) {
+            featureStates[fs.feature.id] = fs;
+        }
+    }
+    return featureStates;
+}
+function getIdentityFeatureState(environment, identity, featureName, overrideTraits) {
+    const featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
+    const matchingFeature = Object.values(featureStates).filter(f => f.feature.name === featureName);
+    if (matchingFeature.length === 0) {
+        throw new errors_js_1.FeatureStateNotFound('Feature State Not Found');
+    }
+    return matchingFeature[0];
+}
+exports.getIdentityFeatureState = getIdentityFeatureState;
+function getIdentityFeatureStates(environment, identity, overrideTraits) {
+    const featureStates = Object.values(getIdentityFeatureStatesDict(environment, identity, overrideTraits));
+    if (environment.project.hideDisabledFlags) {
+        return featureStates.filter(fs => !!fs.enabled);
+    }
+    return featureStates;
+}
+exports.getIdentityFeatureStates = getIdentityFeatureStates;
+function getEnvironmentFeatureState(environment, featureName) {
+    const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
+    if (featuresStates.length === 0) {
+        throw new errors_js_1.FeatureStateNotFound('Feature State Not Found');
+    }
+    return featuresStates[0];
+}
+exports.getEnvironmentFeatureState = getEnvironmentFeatureState;
+function getEnvironmentFeatureStates(environment) {
+    if (environment.project.hideDisabledFlags) {
+        return environment.featureStates.filter(fs => !!fs.enabled);
+    }
+    return environment.featureStates;
+}
+exports.getEnvironmentFeatureStates = getEnvironmentFeatureStates;

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

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

package/build/{flagsmith-engine → cjs/flagsmith-engine}/organisations/util.d.ts

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

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

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

package/build/{flagsmith-engine → cjs/flagsmith-engine}/projects/models.d.ts

@@ -1,5 +1,5 @@
-import { OrganisationModel } from '../organisations/models';
-import { SegmentModel } from '../segments/models';
+import { OrganisationModel } from '../organisations/models.js';
+import { SegmentModel } from '../segments/models.js';
 export declare class ProjectModel {
     id: number;
     name: string;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/projects/models.js

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

package/build/{flagsmith-engine → cjs/flagsmith-engine}/projects/util.d.ts

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

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

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

package/build/{flagsmith-engine → cjs/flagsmith-engine}/segments/evaluators.d.ts

@@ -1,7 +1,7 @@
-import { EnvironmentModel } from '../environments/models';
-import { IdentityModel } from '../identities/models';
-import { TraitModel } from '../identities/traits/models';
-import { SegmentConditionModel, SegmentModel } from './models';
+import { EnvironmentModel } from '../environments/models.js';
+import { IdentityModel } from '../identities/models.js';
+import { TraitModel } from '../identities/traits/models.js';
+import { SegmentConditionModel, SegmentModel } from './models.js';
 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/cjs/flagsmith-engine/segments/evaluators.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traitsMatchSegmentCondition = exports.evaluateIdentityInSegment = exports.getIdentitySegments = void 0;
+const index_js_1 = require("../utils/hashing/index.js");
+const constants_js_1 = require("./constants.js");
+function getIdentitySegments(environment, identity, overrideTraits) {
+    return environment.project.segments.filter(segment => 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.djangoID || 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)))
+        : true;
+    return (matchesConditions &&
+        rule.rules.filter(rule => traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId)).length === rule.rules.length);
+}
+function traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId) {
+    if (condition.operator == constants_js_1.PERCENTAGE_SPLIT) {
+        var hashedPercentage = (0, index_js_1.getHashedPercentateForObjIds)([segmentId, identityId]);
+        return hashedPercentage <= parseFloat(String(condition.value));
+    }
+    const traits = identityTraits.filter(t => t.traitKey === condition.property_);
+    const trait = traits.length > 0 ? traits[0] : undefined;
+    if (condition.operator === constants_js_1.IS_SET) {
+        return !!trait;
+    }
+    else if (condition.operator === constants_js_1.IS_NOT_SET) {
+        return trait == undefined;
+    }
+    return trait ? condition.matchesTraitValue(trait.traitValue) : false;
+}
+exports.traitsMatchSegmentCondition = traitsMatchSegmentCondition;

package/build/{flagsmith-engine → cjs/flagsmith-engine}/segments/models.d.ts

@@ -1,4 +1,4 @@
-import { FeatureStateModel } from '../features/models';
+import { FeatureStateModel } from '../features/models.js';
 export declare const all: (iterable: Array<any>) => boolean;
 export declare const any: (iterable: Array<any>) => boolean;
 export declare const matchingFunctions: {