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

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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationModel = void 0;
+class IntegrationModel {
+    api_key = undefined;
+    base_url = undefined;
+}
+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,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentModel = exports.EnvironmentAPIKeyModel = void 0;
+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;
+        this.name = name;
+        this.clientApiKey = clientApiKey;
+        this.expiresAt = expiresAt;
+    }
+    isValid() {
+        return !!this.active && (!this.expiresAt || this.expiresAt > Date.now());
+    }
+}
+exports.EnvironmentAPIKeyModel = EnvironmentAPIKeyModel;
+class EnvironmentModel {
+    id;
+    apiKey;
+    project;
+    featureStates = [];
+    amplitude_config;
+    segment_config;
+    mixpanel_config;
+    heap_config;
+    constructor(id, apiKey, project) {
+        this.id = id;
+        this.apiKey = apiKey;
+        this.project = project;
+    }
+}
+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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnvironmentAPIKeyModel = exports.buildEnvironmentModel = void 0;
+const util_1 = require("../features/util");
+const util_2 = require("../projects/util");
+const models_1 = require("./models");
+function buildEnvironmentModel(environmentJSON) {
+    const project = (0, util_2.buildProjectModel)(environmentJSON.project);
+    const featureStates = environmentJSON.feature_states.map((fs) => (0, util_1.buildFeatureStateModel)(fs));
+    const environmentModel = new models_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
+    environmentModel.featureStates = featureStates;
+    return environmentModel;
+}
+exports.buildEnvironmentModel = buildEnvironmentModel;
+function buildEnvironmentAPIKeyModel(apiKeyJSON) {
+    const 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,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureStateModel = exports.MultivariateFeatureStateValueModel = exports.MultivariateFeatureOptionModel = exports.FeatureModel = void 0;
+const uuid_1 = require("uuid");
+const hashing_1 = require("../utils/hashing");
+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, uuid_1.v4)();
+    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, uuid_1.v4)();
+    value;
+    multivariateFeatureStateValues = [];
+    constructor(feature, enabled, djangoID, value, featurestateUuid = (0, uuid_1.v4)()) {
+        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;
+    }
+    get_feature_state_value() {
+        return this.getValue();
+    }
+    getMultivariateValue(identityID) {
+        const percentageValue = (0, hashing_1.getHashedPercentateForObjIds)([
+            this.djangoID || this.featurestateUUID,
+            identityID
+        ]);
+        let startPercentage = 0;
+        const sortedF = this.multivariateFeatureStateValues.sort((a, b) => !!(a.id && b.id) ? a.id - b.id : a.mvFsValueUuid > b.mvFsValueUuid ? -1 : 1);
+        for (const myValue of sortedF) {
+            const limit = myValue.percentageAllocation + startPercentage;
+            if (startPercentage <= percentageValue && percentageValue < limit) {
+                return myValue.multivariateFeatureOption.value;
+            }
+            startPercentage = limit;
+        }
+        return this.value;
+    }
+}
+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;
+const models_1 = require("./models");
+function buildFeatureModel(featuresModelJSON) {
+    return new models_1.FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
+}
+exports.buildFeatureModel = buildFeatureModel;
+function buildFeatureStateModel(featuresStateModelJSON) {
+    const featureStateModel = new models_1.FeatureStateModel(buildFeatureModel(featuresStateModelJSON.feature), featuresStateModelJSON.enabled, featuresStateModelJSON.django_id, featuresStateModelJSON.feature_state_value, featuresStateModelJSON.uuid);
+    const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
+        ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv) => {
+            const 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,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityModel = void 0;
+const collections_1 = require("../utils/collections");
+const { v4: uuidv4 } = require('uuid');
+class IdentityModel {
+    identifier;
+    environmentApiKey;
+    createdDate;
+    identityFeatures;
+    identityTraits;
+    identityUuid;
+    djangoID;
+    constructor(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(...identityFeatures);
+        this.environmentApiKey = environmentApiKey;
+        this.identifier = identifier;
+    }
+    get compositeKey() {
+        return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
+    }
+    static generateCompositeKey(env_key, identifier) {
+        return `${env_key}_${identifier}`;
+    }
+    update_traits(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/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,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraitModel = void 0;
+class TraitModel {
+    traitKey;
+    traitValue;
+    constructor(key, value) {
+        this.traitKey = key;
+        this.traitValue = value;
+    }
+}
+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,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIdentityModel = exports.buildTraitModel = void 0;
+const util_1 = require("../features/util");
+const collections_1 = require("../utils/collections");
+const models_1 = require("./models");
+const 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) {
+    const featureList = identityJSON.identity_features
+        ? new collections_1.IdentityFeaturesList(...identityJSON.identity_features.map((f) => (0, util_1.buildFeatureStateModel)(f)))
+        : [];
+    const model = new models_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/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,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironmentFeatureStates = exports.getEnvironmentFeatureState = exports.getIdentityFeatureStates = exports.getIdentityFeatureState = void 0;
+const evaluators_1 = require("./segments/evaluators");
+const errors_1 = require("./utils/errors");
+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_1.getIdentitySegments)(environment, identity, overrideTraits);
+    for (const matchingSegment of identitySegments) {
+        for (const featureState of matchingSegment.featureStates) {
+            // 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;
+        }
+    }
+    // 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_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 Error('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/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;
+}

package/build/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 unique_slug() {
+        return this.id.toString() + '-' + this.name;
+    }
+}
+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;
+const 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,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectModel = void 0;
+class ProjectModel {
+    id;
+    name;
+    organisation;
+    hideDisabledFlags;
+    segments = [];
+    constructor(id, name, hideDisabledFlags, organization) {
+        this.id = id;
+        this.name = name;
+        this.hideDisabledFlags = hideDisabledFlags;
+        this.organisation = organization;
+    }
+}
+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;
+const util_1 = require("../organisations/util");
+const util_2 = require("../segments/util");
+const models_1 = require("./models");
+function buildProjectModel(projectJSON) {
+    const segments = projectJSON['segments']
+        ? projectJSON['segments'].map((s) => (0, util_2.buildSegmentModel)(s))
+        : [];
+    const model = new models_1.ProjectModel(projectJSON.id, projectJSON.name, projectJSON.hide_disabled_flags, (0, util_1.buildOrganizationModel)(projectJSON.organisation));
+    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;