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

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 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,26 @@
+export declare const ALL_RULE = "ALL";
+export declare const ANY_RULE = "ANY";
+export declare const NONE_RULE = "NONE";
+export declare const RULE_TYPES: string[];
+export declare const EQUAL = "EQUAL";
+export declare const GREATER_THAN = "GREATER_THAN";
+export declare const LESS_THAN = "LESS_THAN";
+export declare const LESS_THAN_INCLUSIVE = "LESS_THAN_INCLUSIVE";
+export declare const CONTAINS = "CONTAINS";
+export declare const GREATER_THAN_INCLUSIVE = "GREATER_THAN_INCLUSIVE";
+export declare const NOT_CONTAINS = "NOT_CONTAINS";
+export declare const NOT_EQUAL = "NOT_EQUAL";
+export declare const REGEX = "REGEX";
+export declare const PERCENTAGE_SPLIT = "PERCENTAGE_SPLIT";
+export declare const CONDITION_OPERATORS: {
+    EQUAL: string;
+    GREATER_THAN: string;
+    LESS_THAN: string;
+    LESS_THAN_INCLUSIVE: string;
+    CONTAINS: string;
+    GREATER_THAN_INCLUSIVE: string;
+    NOT_CONTAINS: string;
+    NOT_EQUAL: string;
+    REGEX: string;
+    PERCENTAGE_SPLIT: string;
+};

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

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

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateIdentityInSegment = exports.getIdentitySegments = void 0;
+var hashing_1 = require("../utils/hashing");
+var constants_1 = require("./constants");
+function getIdentitySegments(environment, identity, overrideTraits) {
+    return environment.project.segments.filter(function (segment) {
+        return evaluateIdentityInSegment(identity, segment, overrideTraits);
+    });
+}
+exports.getIdentitySegments = getIdentitySegments;
+function evaluateIdentityInSegment(identity, segment, overrideTraits) {
+    return (segment.rules.length > 0 &&
+        segment.rules.filter(function (rule) {
+            return traitsMatchSegmentRule(overrideTraits || identity.identityTraits, rule, segment.id, identity.compositeKey);
+        }).length === segment.rules.length);
+}
+exports.evaluateIdentityInSegment = evaluateIdentityInSegment;
+function traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId) {
+    var matchesConditions = rule.conditions.length > 0
+        ? rule.matchingFunction()(rule.conditions.map(function (condition) {
+            return traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId);
+        }))
+        : true;
+    return (matchesConditions &&
+        rule.rules.filter(function (rule) {
+            return traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId);
+        }).length === rule.rules.length);
+}
+function traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId) {
+    if (condition.operator == constants_1.PERCENTAGE_SPLIT) {
+        return (0, hashing_1.getHashedPercentateForObjIds)([segmentId, identityId]) <= parseFloat(condition.value);
+    }
+    var traits = identityTraits.filter(function (t) { return t.traitKey === condition.property_; });
+    var trait = traits.length > 0 ? traits[0] : undefined;
+    return trait ? condition.matchesTraitValue(trait.traitValue) : false;
+}

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

@@ -0,0 +1,31 @@
+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 class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS: {
+        [key: string]: string;
+    };
+    operator: string;
+    value: string;
+    property_: string | undefined;
+    constructor(operator: string, value: string, property?: string);
+    matchesTraitValue(traitValue: any): any;
+}
+export declare class SegmentRuleModel {
+    type: string;
+    rules: SegmentRuleModel[];
+    conditions: SegmentConditionModel[];
+    constructor(type: string);
+    static none(iterable: Array<any>): boolean;
+    matchingFunction(): CallableFunction;
+}
+export declare class SegmentModel {
+    id: number;
+    name: string;
+    rules: SegmentRuleModel[];
+    featureStates: FeatureStateModel[];
+    constructor(id: number, name: string);
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentModel = exports.SegmentRuleModel = exports.SegmentConditionModel = exports.matchingFunctions = exports.any = exports.all = void 0;
+var utils_1 = require("../utils");
+var constants_1 = require("./constants");
+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);
+var SegmentConditionModel = /** @class */ (function () {
+    function SegmentConditionModel(operator, value, property) {
+        var _a;
+        this.EXCEPTION_OPERATOR_METHODS = (_a = {},
+            _a[constants_1.NOT_CONTAINS] = 'evaluateNotContains',
+            _a[constants_1.REGEX] = 'evaluateRegex',
+            _a);
+        this.operator = operator;
+        this.value = value;
+        this.property_ = property;
+    }
+    SegmentConditionModel.prototype.matchesTraitValue = function (traitValue) {
+        var _this = this;
+        var evaluators = {
+            evaluateNotContains: function (traitValue) {
+                return !traitValue.includes(_this.value);
+            },
+            evaluateRegex: function (traitValue) {
+                return !!traitValue.match(new RegExp(_this.value));
+            }
+        };
+        // TODO: move this logic to the evaluator module
+        if (this.EXCEPTION_OPERATOR_METHODS[this.operator]) {
+            var evaluatorFunction = evaluators[this.EXCEPTION_OPERATOR_METHODS[this.operator]];
+            return evaluatorFunction(traitValue);
+        }
+        var defaultFunction = function (x, y) { return false; };
+        var matchingFunction = exports.matchingFunctions[this.operator] || defaultFunction;
+        var castToTypeOfTraitValue = (0, utils_1.getCastingFunction)(traitValue);
+        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,4 @@
+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;

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

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

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityFeaturesList = void 0;
+var IdentityFeaturesList = /** @class */ (function (_super) {
+    __extends(IdentityFeaturesList, _super);
+    function IdentityFeaturesList() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return IdentityFeaturesList;
+}(Array));
+exports.IdentityFeaturesList = IdentityFeaturesList;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureStateNotFound = void 0;
+var FeatureStateNotFound = /** @class */ (function (_super) {
+    __extends(FeatureStateNotFound, _super);
+    function FeatureStateNotFound() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return FeatureStateNotFound;
+}(Error));
+exports.FeatureStateNotFound = FeatureStateNotFound;

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

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

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

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHashedPercentateForObjIds = void 0;
+var md5_1 = __importDefault(require("md5"));
+var big_integer_1 = __importDefault(require("big-integer"));
+var makeRepeated = function (arr, repeats) {
+    return Array.from({ length: repeats }, function () { return arr; }).flat();
+};
+// https://stackoverflow.com/questions/12532871/how-to-convert-a-very-large-hex-number-to-decimal-in-javascript
+function h2d(s) {
+    function add(x, y) {
+        var c = 0, r = [];
+        var x = x.split('').map(Number);
+        var y = y.split('').map(Number);
+        while (x.length || y.length) {
+            var s = (x.pop() || 0) + (y.pop() || 0) + c;
+            r.unshift(s < 10 ? s : s - 10);
+            c = s < 10 ? 0 : 1;
+        }
+        if (c)
+            r.unshift(c);
+        return r.join('');
+    }
+    var dec = '0';
+    s.split('').forEach(function (chr) {
+        var n = parseInt(chr, 16);
+        for (var t = 8; t; t >>= 1) {
+            dec = add(dec, dec);
+            if (n & t)
+                dec = add(dec, '1');
+        }
+    });
+    return dec;
+}
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @param  {} iterations=1 num times to include each id in the generated string to hash
+ * @returns number number between 0 (inclusive) and 100 (exclusive)
+ */
+function getHashedPercentateForObjIds(objectIds, iterations) {
+    if (iterations === void 0) { iterations = 1; }
+    var toHash = makeRepeated(objectIds, iterations).join(',');
+    var hashedValue = (0, md5_1.default)(toHash);
+    var hashedInt = (0, big_integer_1.default)(h2d(hashedValue));
+    var value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
+    if (value === 100) {
+        /* istanbul ignore next */
+        return getHashedPercentateForObjIds(objectIds, iterations + 1);
+    }
+    return value;
+}
+exports.getHashedPercentateForObjIds = getHashedPercentateForObjIds;

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

@@ -0,0 +1 @@
+export declare function getCastingFunction(input: any): CallableFunction;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCastingFunction = void 0;
+function getCastingFunction(input) {
+    switch (typeof input) {
+        case 'boolean':
+            return function (x) { return !['False', 'false'].includes(x); };
+        case 'number':
+            return function (x) { return parseFloat(x); };
+        default:
+            return function (x) { return String(x); };
+    }
+}
+exports.getCastingFunction = getCastingFunction;

package/build/index.d.ts

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

package/build/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flagsmith = void 0;
+var sdk_1 = __importDefault(require("./sdk"));
+var sdk_2 = require("./sdk");
+Object.defineProperty(exports, "Flagsmith", { enumerable: true, get: function () { return sdk_2.Flagsmith; } });
+// export default Flagsmith;
+module.exports = sdk_1.default;