@statsig/on-device-eval-core 3.12.0

package/LICENSE

@@ -0,0 +1,14 @@
+ISC License (ISC)
+Copyright (c) 2021, Statsig, Inc.
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+Statsig helps you move faster with feature gates (feature flags), and/or dynamic configs. It also allows you to run A/B/n tests to validate your new features and understand their impact on your KPIs. If you're new to Statsig, check out our product and create an account at [statsig.com](https://www.statsig.com/?ref=gh_jsm).
+
+<h1 align="center">
+	<a href="https://statsig.com/?ref=gh_jsm">
+		<img src="https://github.com/statsig-io/js-client-monorepo/assets/95646168/ae5499ed-20ff-4584-bf21-8857f800d485" />
+	</a>
+    <div />
+	<a href="https://statsig.com/?ref=gh_jsm">Statsig</a>
+</h1>
+
+<p align="center">
+	<a href="https://github.com/statsig-io/js-client-monorepo/blob/main/LICENSE">
+        	<img src="https://img.shields.io/badge/license-ISC-blue.svg?colorA=1b2528&colorB=ccfbc7&style=for-the-badge">
+    	</a>
+	<a href="https://www.npmjs.com/package/@statsig/js-client">
+        	<img src="https://img.shields.io/npm/v/@statsig/js-client.svg?colorA=1b2528&colorB=b2d3ff&style=for-the-badge">
+    	</a>
+	<a href="https://statsig.com/community?ref=gh_jsm">
+        	<img src="https://img.shields.io/badge/slack-statsig-brightgreen.svg?logo=slack&colorA=1b2528&colorB=FFF8BA&style=for-the-badge">
+    	</a>
+</p>
+
+## Getting Started
+
+Read through the [Documentation](https://docs.statsig.com/client/javascript-sdk?ref=gh_jsm) or check out the [Samples](samples/).
+
+## Packages
+
+Clients
+
+- Precomputed Evaluations (Recommended) [[npm](https://www.npmjs.com/package/@statsig/js-client)] [[source](https://github.com/statsig-io/js-client-monorepo/tree/main/packages/js-client)]
+- On Device Evaluations [[npm](https://www.npmjs.com/package/@statsig/js-on-device-eval-client)] [[source](https://github.com/statsig-io/js-client-monorepo/tree/main/packages/js-on-device-eval-client)]
+
+Product Bundles
+
+- Session Replay [[npm](https://www.npmjs.com/package/@statsig/session-replay)] [[source](https://github.com/statsig-io/js-client-monorepo/tree/main/packages/session-replay)]
+- Web Analytics [[npm](https://www.npmjs.com/package/@statsig/web-analytics)] [[source](https://github.com/statsig-io/js-client-monorepo/tree/main/packages/web-analytics)]
+
+Framework Specific Bindings
+
+- React [[npm](https://www.npmjs.com/package/@statsig/react-bindings)] [[source](https://github.com/statsig-io/js-client-monorepo/tree/main/packages/react-bindings)]
+
+- React Native [[npm](https://www.npmjs.com/package/@statsig/react-native-bindings)] [[source](https://github.com/statsig-io/js-client-monorepo/tree/main/packages/react-native-bindings)]
+
+- React Native (Expo) [[npm](https://www.npmjs.com/package/@statsig/expo-bindings)] [[source](https://github.com/statsig-io/js-client-monorepo/tree/main/packages/expo-bindings)]
+
+## Community
+
+If you need any assitance or just have a question, feel free to reach out to us on [Slack](https://statsig.com/community?ref=gh_jsm).

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@statsig/on-device-eval-core",
+  "version": "3.12.0",
+  "dependencies": {
+    "@statsig/client-core": "3.12.0",
+    "@statsig/sha256": "3.12.0"
+  },
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts"
+}

package/src/EvaluationComparison.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    compareNumbers(left: unknown, right: unknown, operator: string): boolean;
+    compareVersions(left: unknown, right: unknown, operator: string): boolean;
+    compareStringInArray(value: unknown, array: unknown, operator: string): boolean;
+    compareStringWithRegEx(value: unknown, target: unknown): boolean;
+    compareTime(left: unknown, right: unknown, operator: string): boolean;
+    arrayHasValue(value: unknown[], target: string[]): boolean;
+    arrayHasAllValues(value: unknown[], target: string[]): boolean;
+};
+export default _default;

package/src/EvaluationComparison.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    compareNumbers(left, right, operator) {
+        if (left == null || right == null) {
+            return false;
+        }
+        const numA = Number(left);
+        const numB = Number(right);
+        if (isNaN(numA) || isNaN(numB)) {
+            return false;
+        }
+        switch (operator) {
+            case 'gt':
+                return left > right;
+            case 'gte':
+                return left >= right;
+            case 'lt':
+                return left < right;
+            case 'lte':
+                return left <= right;
+            default:
+                return false;
+        }
+    },
+    compareVersions(left, right, operator) {
+        if (left == null || right == null) {
+            return false;
+        }
+        let leftStr = String(left);
+        let rightStr = String(right);
+        const removeSuffix = (str) => {
+            const index = str.indexOf('-');
+            return index !== -1 ? str.substring(0, index) : str;
+        };
+        leftStr = removeSuffix(leftStr);
+        rightStr = removeSuffix(rightStr);
+        const comparison = (leftStr, rightStr) => {
+            const leftParts = leftStr.split('.').map((part) => parseInt(part));
+            const rightParts = rightStr.split('.').map((part) => parseInt(part));
+            let i = 0;
+            while (i < Math.max(leftParts.length, rightParts.length)) {
+                const leftCount = i < leftParts.length ? leftParts[i] : 0;
+                const rightCount = i < rightParts.length ? rightParts[i] : 0;
+                if (leftCount < rightCount) {
+                    return -1;
+                }
+                if (leftCount > rightCount) {
+                    return 1;
+                }
+                i++;
+            }
+            return 0;
+        };
+        const result = comparison(leftStr, rightStr);
+        switch (operator) {
+            case 'version_gt':
+                return result > 0;
+            case 'version_gte':
+                return result >= 0;
+            case 'version_lt':
+                return result < 0;
+            case 'version_lte':
+                return result <= 0;
+            case 'version_eq':
+                return result === 0;
+            case 'version_neq':
+                return result !== 0;
+            default:
+                return false;
+        }
+    },
+    compareStringInArray(value, array, operator) {
+        if (!Array.isArray(array)) {
+            return false;
+        }
+        const ignoreCase = operator !== 'any_case_sensitive' && operator !== 'none_case_sensitive';
+        const result = array.findIndex((current) => {
+            const valueString = String(value);
+            const currentString = String(current);
+            const left = ignoreCase ? valueString.toLowerCase() : valueString;
+            const right = ignoreCase ? currentString.toLowerCase() : currentString;
+            switch (operator) {
+                case 'any':
+                case 'none':
+                case 'any_case_sensitive':
+                case 'none_case_sensitive':
+                    return left === right;
+                case 'str_starts_with_any':
+                    return left.startsWith(right);
+                case 'str_ends_with_any':
+                    return left.endsWith(right);
+                case 'str_contains_any':
+                case 'str_contains_none':
+                    return left.includes(right);
+                default:
+                    return false;
+            }
+        }) !== -1;
+        switch (operator) {
+            case 'none':
+            case 'none_case_sensitive':
+            case 'str_contains_none':
+                return !result;
+            default:
+                return result;
+        }
+    },
+    compareStringWithRegEx(value, target) {
+        try {
+            const valueString = String(value);
+            if (valueString.length < 1000) {
+                return new RegExp(String(target)).test(valueString);
+            }
+        }
+        catch (e) {
+            // noop
+        }
+        return false;
+    },
+    compareTime(left, right, operator) {
+        if (left == null || right == null) {
+            return false;
+        }
+        try {
+            // Try to parse into date as a string first, if not, try unixtime
+            let dateLeft = new Date(String(left));
+            if (isNaN(dateLeft.getTime())) {
+                dateLeft = new Date(Number(left));
+            }
+            let dateRight = new Date(String(right));
+            if (isNaN(dateRight.getTime())) {
+                dateRight = new Date(Number(right));
+            }
+            const timeLeft = dateLeft.getTime();
+            const timeRight = dateRight.getTime();
+            if (isNaN(timeLeft) || isNaN(timeRight)) {
+                return false;
+            }
+            switch (operator) {
+                case 'before':
+                    return timeLeft < timeRight;
+                case 'after':
+                    return timeLeft > timeRight;
+                case 'on':
+                    return _startOfDay(dateLeft) === _startOfDay(dateRight);
+                default:
+                    return false;
+            }
+        }
+        catch (e) {
+            // malformatted input, returning false
+            return false;
+        }
+    },
+    arrayHasValue(value, target) {
+        const valueSet = new Set(value);
+        for (let i = 0; i < target.length; i++) {
+            if (valueSet.has(target[i]) ||
+                valueSet.has(parseFloat(target[i]))) {
+                return true;
+            }
+        }
+        return false;
+    },
+    arrayHasAllValues(value, target) {
+        const valueSet = new Set(value);
+        for (let i = 0; i < target.length; i++) {
+            if (!valueSet.has(target[i]) &&
+                !valueSet.has(parseFloat(target[i]))) {
+                return false;
+            }
+        }
+        return true;
+    },
+};
+function _startOfDay(date) {
+    date.setUTCHours(0, 0, 0, 0);
+    return date.getTime();
+}

package/src/EvaluationResult.d.ts

@@ -0,0 +1,17 @@
+import { DynamicConfigEvaluation, GateEvaluation, LayerEvaluation, SecondaryExposure, Spec } from '@statsig/client-core';
+export type EvaluationResult = {
+    readonly unsupported: boolean;
+    readonly bool_value: boolean;
+    readonly rule_id: string;
+    readonly secondary_exposures: SecondaryExposure[];
+    readonly json_value: Record<string, unknown>;
+    readonly explicit_parameters: string[] | null;
+    readonly allocated_experiment_name: string | null;
+    readonly undelegated_secondary_exposures: SecondaryExposure[] | undefined;
+    readonly is_experiment_group: boolean;
+    readonly group_name: string | null;
+};
+export declare function makeEvalResult(overrides: Partial<EvaluationResult>): EvaluationResult;
+export declare function resultToGateEval(spec: Spec, result: EvaluationResult): GateEvaluation;
+export declare function resultToConfigEval(spec: Spec, result: EvaluationResult): DynamicConfigEvaluation;
+export declare function resultToLayerEval(layerSpec: Spec, experimentSpec: Spec | null, result: EvaluationResult): LayerEvaluation;

package/src/EvaluationResult.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resultToLayerEval = exports.resultToConfigEval = exports.resultToGateEval = exports.makeEvalResult = void 0;
+function makeEvalResult(overrides) {
+    const base = {
+        unsupported: false,
+        bool_value: false,
+        rule_id: '',
+        secondary_exposures: [],
+        json_value: {},
+        explicit_parameters: null,
+        allocated_experiment_name: null,
+        is_experiment_group: false,
+        group_name: null,
+        undelegated_secondary_exposures: undefined,
+    };
+    return Object.assign(Object.assign({}, base), overrides);
+}
+exports.makeEvalResult = makeEvalResult;
+function resultToGateEval(spec, result) {
+    var _a;
+    return {
+        name: spec.name,
+        id_type: spec.idType,
+        rule_id: result.rule_id,
+        value: result.bool_value,
+        secondary_exposures: result.secondary_exposures,
+        version: (_a = spec.version) === null || _a === void 0 ? void 0 : _a.toString(),
+    };
+}
+exports.resultToGateEval = resultToGateEval;
+function resultToConfigEval(spec, result) {
+    var _a, _b, _c;
+    return {
+        name: spec.name,
+        id_type: spec.idType,
+        rule_id: result.rule_id,
+        value: result.json_value,
+        secondary_exposures: result.secondary_exposures,
+        group: (_a = result.group_name) !== null && _a !== void 0 ? _a : '',
+        group_name: (_b = result.group_name) !== null && _b !== void 0 ? _b : undefined,
+        is_device_based: false,
+        is_experiment_active: spec.isActive,
+        is_user_in_experiment: result.is_experiment_group,
+        version: (_c = spec.version) === null || _c === void 0 ? void 0 : _c.toString(),
+        passed: result.bool_value,
+    };
+}
+exports.resultToConfigEval = resultToConfigEval;
+function resultToLayerEval(layerSpec, experimentSpec, result) {
+    var _a, _b, _c, _d, _e;
+    return {
+        name: layerSpec.name,
+        rule_id: result.rule_id,
+        value: result.json_value,
+        secondary_exposures: result.secondary_exposures,
+        undelegated_secondary_exposures: result.undelegated_secondary_exposures,
+        allocated_experiment_name: (_a = result.allocated_experiment_name) !== null && _a !== void 0 ? _a : '',
+        explicit_parameters: (_b = result.explicit_parameters) !== null && _b !== void 0 ? _b : [],
+        group: (_c = result.group_name) !== null && _c !== void 0 ? _c : '',
+        group_name: (_d = result.group_name) !== null && _d !== void 0 ? _d : undefined,
+        is_device_based: false,
+        is_experiment_active: experimentSpec === null || experimentSpec === void 0 ? void 0 : experimentSpec.isActive,
+        is_user_in_experiment: result.is_experiment_group,
+        version: (_e = layerSpec.version) === null || _e === void 0 ? void 0 : _e.toString(),
+    };
+}
+exports.resultToLayerEval = resultToLayerEval;

package/src/Evaluator.d.ts

@@ -0,0 +1,22 @@
+import { DynamicConfigEvaluation, EvaluationDetails, GateEvaluation, LayerEvaluation, StatsigUserInternal } from '@statsig/client-core';
+import { SpecStore } from './SpecStore';
+type DetailedEvaluation<T> = {
+    evaluation: T | null;
+    details: EvaluationDetails;
+};
+export declare class Evaluator {
+    private _store;
+    constructor(_store: SpecStore);
+    evaluateGate(name: string, user: StatsigUserInternal): DetailedEvaluation<GateEvaluation>;
+    evaluateConfig(name: string, user: StatsigUserInternal): DetailedEvaluation<DynamicConfigEvaluation>;
+    evaluateLayer(name: string, user: StatsigUserInternal): DetailedEvaluation<LayerEvaluation>;
+    private _getSpecAndDetails;
+    private _getEvaluationDetails;
+    private _evaluateSpec;
+    private _evaluateRule;
+    private _evaluateCondition;
+    private _evaluateDelegate;
+    private _evaluateNestedGate;
+    private _evaluateMultiNestedGates;
+}
+export {};

package/src/Evaluator.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evaluator = void 0;
+const sha256_1 = require("@statsig/sha256");
+const EvaluationComparison_1 = require("./EvaluationComparison");
+const EvaluationResult_1 = require("./EvaluationResult");
+const CONDITION_SEGMENT_COUNT = 10 * 1000;
+const USER_BUCKET_COUNT = 1000;
+class Evaluator {
+    constructor(_store) {
+        this._store = _store;
+    }
+    evaluateGate(name, user) {
+        const { spec, details } = this._getSpecAndDetails('gate', name);
+        if (!spec) {
+            return { evaluation: null, details };
+        }
+        const evaluation = (0, EvaluationResult_1.resultToGateEval)(spec, this._evaluateSpec(spec, user));
+        return { evaluation, details };
+    }
+    evaluateConfig(name, user) {
+        const { spec, details } = this._getSpecAndDetails('config', name);
+        if (!spec) {
+            return { evaluation: null, details };
+        }
+        const evaluation = (0, EvaluationResult_1.resultToConfigEval)(spec, this._evaluateSpec(spec, user));
+        return { evaluation, details };
+    }
+    evaluateLayer(name, user) {
+        var _a;
+        const { spec, details } = this._getSpecAndDetails('layer', name);
+        if (!spec) {
+            return { evaluation: null, details };
+        }
+        const result = this._evaluateSpec(spec, user);
+        const experimentName = (_a = result === null || result === void 0 ? void 0 : result.allocated_experiment_name) !== null && _a !== void 0 ? _a : '';
+        const experimentSpec = this._store.getSpecAndSourceInfo('config', experimentName).spec;
+        const evaluation = (0, EvaluationResult_1.resultToLayerEval)(spec, experimentSpec, result);
+        return { evaluation, details };
+    }
+    _getSpecAndDetails(kind, name) {
+        const specAndSourceInfo = this._store.getSpecAndSourceInfo(kind, name);
+        const details = this._getEvaluationDetails(specAndSourceInfo);
+        return { details, spec: specAndSourceInfo.spec };
+    }
+    _getEvaluationDetails(info) {
+        const { source, spec, lcut, receivedAt } = info;
+        if (source === 'Uninitialized' || source === 'NoValues') {
+            return { reason: source };
+        }
+        const subreason = spec == null ? 'Unrecognized' : 'Recognized';
+        const reason = `${source}:${subreason}`;
+        return { reason, lcut, receivedAt };
+    }
+    _evaluateSpec(spec, user) {
+        const defaultValue = _isRecord(spec.defaultValue)
+            ? spec.defaultValue
+            : undefined;
+        if (!spec.enabled) {
+            return (0, EvaluationResult_1.makeEvalResult)({
+                json_value: defaultValue,
+                rule_id: 'disabled',
+            });
+        }
+        const exposures = [];
+        for (const rule of spec.rules) {
+            const result = this._evaluateRule(rule, user);
+            if (result.unsupported) {
+                return result;
+            }
+            exposures.push(...result.secondary_exposures);
+            if (!result.bool_value) {
+                continue;
+            }
+            const delegateResult = this._evaluateDelegate(rule.configDelegate, user, exposures);
+            if (delegateResult) {
+                return delegateResult;
+            }
+            const pass = _evalPassPercent(rule, user, spec);
+            return (0, EvaluationResult_1.makeEvalResult)({
+                rule_id: result.rule_id,
+                bool_value: pass,
+                json_value: pass ? result.json_value : defaultValue,
+                secondary_exposures: exposures,
+                undelegated_secondary_exposures: exposures,
+                is_experiment_group: result.is_experiment_group,
+                group_name: result.group_name,
+            });
+        }
+        return (0, EvaluationResult_1.makeEvalResult)({
+            json_value: defaultValue,
+            secondary_exposures: exposures,
+            undelegated_secondary_exposures: exposures,
+            rule_id: 'default',
+        });
+    }
+    _evaluateRule(rule, user) {
+        const exposures = [];
+        let pass = true;
+        for (const condition of rule.conditions) {
+            const result = this._evaluateCondition(condition, user);
+            if (result.unsupported) {
+                return result;
+            }
+            exposures.push(...result.secondary_exposures);
+            if (!result.bool_value) {
+                pass = false;
+            }
+        }
+        return (0, EvaluationResult_1.makeEvalResult)({
+            rule_id: rule.id,
+            bool_value: pass,
+            json_value: _isRecord(rule.returnValue) ? rule.returnValue : undefined,
+            secondary_exposures: exposures,
+            is_experiment_group: rule.isExperimentGroup === true,
+            group_name: rule.groupName,
+        });
+    }
+    _evaluateCondition(condition, user) {
+        var _a, _b, _c;
+        let value = null;
+        let pass = false;
+        const field = condition.field;
+        const target = condition.targetValue;
+        const idType = condition.idType;
+        const type = condition.type;
+        switch (type) {
+            case 'public':
+                return (0, EvaluationResult_1.makeEvalResult)({ bool_value: true });
+            case 'pass_gate':
+            case 'fail_gate': {
+                const name = String(target);
+                const result = this._evaluateNestedGate(name, user);
+                return (0, EvaluationResult_1.makeEvalResult)({
+                    bool_value: type === 'fail_gate' ? !result.bool_value : result.bool_value,
+                    secondary_exposures: result.secondary_exposures,
+                });
+            }
+            case 'multi_pass_gate':
+            case 'multi_fail_gate':
+                return this._evaluateMultiNestedGates(target, type, user);
+            case 'user_field':
+            case 'ip_based':
+            case 'ua_based':
+                value = _getFromUser(user, field);
+                break;
+            case 'environment_field':
+                value = _getFromEnvironment(user, field);
+                break;
+            case 'current_time':
+                value = Date.now();
+                break;
+            case 'user_bucket': {
+                const salt = String((_b = (_a = condition.additionalValues) === null || _a === void 0 ? void 0 : _a['salt']) !== null && _b !== void 0 ? _b : '');
+                const unitID = (_c = _getUnitIDFromUser(user, idType)) !== null && _c !== void 0 ? _c : '';
+                const userHash = _computeUserHash(salt + '.' + unitID);
+                value = Number(userHash % BigInt(USER_BUCKET_COUNT));
+                break;
+            }
+            case 'unit_id':
+                value = _getUnitIDFromUser(user, idType);
+                break;
+            default:
+                return (0, EvaluationResult_1.makeEvalResult)({ unsupported: true });
+        }
+        const operator = condition.operator;
+        switch (operator) {
+            case 'gt':
+            case 'gte':
+            case 'lt':
+            case 'lte':
+                pass = EvaluationComparison_1.default.compareNumbers(value, target, operator);
+                break;
+            case 'version_gt':
+            case 'version_gte':
+            case 'version_lt':
+            case 'version_lte':
+            case 'version_eq':
+            case 'version_neq':
+                pass = EvaluationComparison_1.default.compareVersions(value, target, operator);
+                break;
+            case 'any':
+            case 'none':
+            case 'str_starts_with_any':
+            case 'str_ends_with_any':
+            case 'str_contains_any':
+            case 'str_contains_none':
+            case 'any_case_sensitive':
+            case 'none_case_sensitive':
+                pass = EvaluationComparison_1.default.compareStringInArray(value, target, operator);
+                break;
+            case 'str_matches':
+                pass = EvaluationComparison_1.default.compareStringWithRegEx(value, target);
+                break;
+            case 'before':
+            case 'after':
+            case 'on':
+                pass = EvaluationComparison_1.default.compareTime(value, target, operator);
+                break;
+            case 'eq':
+                // eslint-disable-next-line eqeqeq
+                pass = value == target;
+                break;
+            case 'neq':
+                // eslint-disable-next-line eqeqeq
+                pass = value != target;
+                break;
+            case 'in_segment_list':
+            case 'not_in_segment_list':
+                return (0, EvaluationResult_1.makeEvalResult)({ unsupported: true });
+            case 'array_contains_any':
+            case 'array_contains_none': {
+                if (!Array.isArray(target)) {
+                    pass = false;
+                    break;
+                }
+                if (!Array.isArray(value)) {
+                    pass = false;
+                    break;
+                }
+                const res = EvaluationComparison_1.default.arrayHasValue(value, target);
+                pass = operator === 'array_contains_any' ? res : !res;
+                break;
+            }
+            case 'array_contains_all':
+            case 'not_array_contains_all': {
+                if (!Array.isArray(target)) {
+                    pass = false;
+                    break;
+                }
+                if (!Array.isArray(value)) {
+                    pass = false;
+                    break;
+                }
+                const res = EvaluationComparison_1.default.arrayHasAllValues(value, target);
+                pass = operator === 'array_contains_all' ? res : !res;
+                break;
+            }
+        }
+        return (0, EvaluationResult_1.makeEvalResult)({ bool_value: pass });
+    }
+    _evaluateDelegate(configDelegate, user, exposures) {
+        if (!configDelegate) {
+            return null;
+        }
+        const { spec } = this._store.getSpecAndSourceInfo('config', configDelegate);
+        if (!spec) {
+            return null;
+        }
+        const result = this._evaluateSpec(spec, user);
+        return (0, EvaluationResult_1.makeEvalResult)(Object.assign(Object.assign({}, result), { allocated_experiment_name: configDelegate, explicit_parameters: spec.explicitParameters, secondary_exposures: exposures.concat(result.secondary_exposures), undelegated_secondary_exposures: exposures }));
+    }
+    _evaluateNestedGate(name, user) {
+        const exposures = [];
+        let pass = false;
+        const { spec } = this._store.getSpecAndSourceInfo('gate', name);
+        if (spec) {
+            const result = this._evaluateSpec(spec, user);
+            if (result.unsupported) {
+                return result;
+            }
+            pass = result.bool_value;
+            exposures.push(...result.secondary_exposures);
+            exposures.push({
+                gate: name,
+                gateValue: String(pass),
+                ruleID: result.rule_id,
+            });
+        }
+        return (0, EvaluationResult_1.makeEvalResult)({
+            bool_value: pass,
+            secondary_exposures: exposures,
+        });
+    }
+    _evaluateMultiNestedGates(gates, type, user) {
+        if (!Array.isArray(gates)) {
+            return (0, EvaluationResult_1.makeEvalResult)({ unsupported: true });
+        }
+        const isMultiPassType = type === 'multi_pass_gate';
+        const exposures = [];
+        let pass = false;
+        for (const name of gates) {
+            if (typeof name !== 'string') {
+                return (0, EvaluationResult_1.makeEvalResult)({ unsupported: true });
+            }
+            const result = this._evaluateNestedGate(name, user);
+            if (result.unsupported) {
+                return result;
+            }
+            exposures.push(...result.secondary_exposures);
+            if (isMultiPassType
+                ? result.bool_value === true
+                : result.bool_value === false) {
+                pass = true;
+                break;
+            }
+        }
+        return (0, EvaluationResult_1.makeEvalResult)({
+            bool_value: pass,
+            secondary_exposures: exposures,
+        });
+    }
+}
+exports.Evaluator = Evaluator;
+function _getUnitIDFromUser(user, idType) {
+    var _a, _b, _c;
+    if (typeof idType === 'string' && idType.toLowerCase() !== 'userid') {
+        return (_b = (_a = user.customIDs) === null || _a === void 0 ? void 0 : _a[idType]) !== null && _b !== void 0 ? _b : (_c = user === null || user === void 0 ? void 0 : user.customIDs) === null || _c === void 0 ? void 0 : _c[idType.toLowerCase()];
+    }
+    return user.userID;
+}
+function _evalPassPercent(rule, user, config) {
+    var _a, _b;
+    if (rule.passPercentage === 100) {
+        return true;
+    }
+    if (rule.passPercentage === 0) {
+        return false;
+    }
+    const hash = _computeUserHash(config.salt +
+        '.' +
+        ((_a = rule.salt) !== null && _a !== void 0 ? _a : rule.id) +
+        '.' +
+        ((_b = _getUnitIDFromUser(user, rule.idType)) !== null && _b !== void 0 ? _b : ''));
+    return (Number(hash % BigInt(CONDITION_SEGMENT_COUNT)) < rule.passPercentage * 100);
+}
+function _computeUserHash(userHash) {
+    const sha256 = (0, sha256_1.SHA256)(userHash);
+    return sha256.dataView().getBigUint64(0, false);
+}
+function _getFromEnvironment(user, field) {
+    if (field == null) {
+        return null;
+    }
+    return _getParameterCaseInsensitive(user.statsigEnvironment, field);
+}
+function _getParameterCaseInsensitive(object, key) {
+    if (object == null) {
+        return undefined;
+    }
+    const asLowercase = key.toLowerCase();
+    const keyMatch = Object.keys(object).find((k) => k.toLowerCase() === asLowercase);
+    if (keyMatch === undefined) {
+        return undefined;
+    }
+    return object[keyMatch];
+}
+function _getFromUser(user, field) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    if (field == null || typeof user !== 'object' || user == null) {
+        return null;
+    }
+    const indexableUser = user;
+    return ((_h = (_f = (_d = (_b = (_a = indexableUser[field]) !== null && _a !== void 0 ? _a : indexableUser[field.toLowerCase()]) !== null && _b !== void 0 ? _b : (_c = user === null || user === void 0 ? void 0 : user.custom) === null || _c === void 0 ? void 0 : _c[field]) !== null && _d !== void 0 ? _d : (_e = user === null || user === void 0 ? void 0 : user.custom) === null || _e === void 0 ? void 0 : _e[field.toLowerCase()]) !== null && _f !== void 0 ? _f : (_g = user === null || user === void 0 ? void 0 : user.privateAttributes) === null || _g === void 0 ? void 0 : _g[field]) !== null && _h !== void 0 ? _h : (_j = user === null || user === void 0 ? void 0 : user.privateAttributes) === null || _j === void 0 ? void 0 : _j[field.toLowerCase()]);
+}
+function _isRecord(obj) {
+    return obj != null && typeof obj === 'object';
+}

package/src/SpecStore.d.ts

@@ -0,0 +1,24 @@
+import { DataAdapterResult, DataSource, DownloadConfigSpecsResponse, Spec } from '@statsig/client-core';
+export type SpecAndSourceInfo = {
+    spec: Spec | null;
+    source: DataSource;
+    lcut: number;
+    receivedAt: number;
+};
+export type SpecKind = 'gate' | 'config' | 'layer';
+export declare class SpecStore {
+    private _rawValues;
+    private _values;
+    private _source;
+    private _lcut;
+    private _receivedAt;
+    private _defaultEnvironment;
+    getValues(): DownloadConfigSpecsResponse | null;
+    getSource(): DataSource;
+    getDefaultEnvironment(): string | null;
+    setValuesFromDataAdapter(result: DataAdapterResult | null): void;
+    reset(): void;
+    finalize(): void;
+    getSpecAndSourceInfo(kind: SpecKind, name: string): SpecAndSourceInfo;
+    private _getSpecs;
+}

package/src/SpecStore.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecStore = void 0;
+const client_core_1 = require("@statsig/client-core");
+function _parseResponse(values) {
+    return (0, client_core_1._typedJsonParse)(values, 'has_updates', 'DownloadConfigSpecsResponse');
+}
+class SpecStore {
+    constructor() {
+        this._rawValues = null;
+        this._values = null;
+        this._source = 'Uninitialized';
+        this._lcut = 0;
+        this._receivedAt = 0;
+        this._defaultEnvironment = null;
+    }
+    getValues() {
+        return this._rawValues ? _parseResponse(this._rawValues) : null;
+    }
+    getSource() {
+        return this._source;
+    }
+    getDefaultEnvironment() {
+        return this._defaultEnvironment;
+    }
+    setValuesFromDataAdapter(result) {
+        var _a;
+        if (!result) {
+            return;
+        }
+        const values = _parseResponse(result.data);
+        if ((values === null || values === void 0 ? void 0 : values.has_updates) !== true) {
+            return;
+        }
+        this._lcut = values.time;
+        this._receivedAt = result.receivedAt;
+        this._source = result.source;
+        this._values = values;
+        this._rawValues = result.data;
+        this._defaultEnvironment = (_a = values.default_environment) !== null && _a !== void 0 ? _a : null;
+    }
+    reset() {
+        this._values = null;
+        this._rawValues = null;
+        this._source = 'Loading';
+    }
+    finalize() {
+        if (this._values) {
+            return;
+        }
+        this._source = 'NoValues';
+    }
+    getSpecAndSourceInfo(kind, name) {
+        var _a;
+        // todo: use Object instead of Array
+        const specs = this._getSpecs(kind);
+        return {
+            spec: (_a = specs === null || specs === void 0 ? void 0 : specs.find((spec) => spec.name === name)) !== null && _a !== void 0 ? _a : null,
+            source: this._source,
+            lcut: this._lcut,
+            receivedAt: this._receivedAt,
+        };
+    }
+    _getSpecs(kind) {
+        var _a, _b, _c;
+        switch (kind) {
+            case 'gate':
+                return (_a = this._values) === null || _a === void 0 ? void 0 : _a.feature_gates;
+            case 'config':
+                return (_b = this._values) === null || _b === void 0 ? void 0 : _b.dynamic_configs;
+            case 'layer':
+                return (_c = this._values) === null || _c === void 0 ? void 0 : _c.layer_configs;
+        }
+    }
+}
+exports.SpecStore = SpecStore;

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Evaluator';
+export * from './SpecStore';

package/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Evaluator"), exports);
+__exportStar(require("./SpecStore"), exports);