@kenji71089/evaluation 0.0.1

package/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.0.1"
+}

package/README.md

@@ -0,0 +1,9 @@
+# Evaluation module for Node.JS
+
+## Setup
+```export NPM_TOKEN="YOUR_NPM_TOKEN"```
+```make init```
+```make copy_proto_generated_code```
+
+## Unit tests
+```make test```

package/eslint.config.mjs

@@ -0,0 +1,27 @@
+import tsEslint from 'typescript-eslint';
+import tsParser from '@typescript-eslint/parser';
+import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
+
+export default [
+  {
+    files: ['src/**/*.ts', 'test/**/*.ts'],
+    ignores: ['**/*.d.ts', 'src/google/', 'src/protoc-gen-openapiv2/', 'src/proto/'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        sourceType: 'module',
+        project: [`tsconfig.json`, `tsconfig.test.json`],
+      },
+      globals: {
+        node: true,
+      },
+    },
+    plugins: {
+      ...tsEslint.configs.recommended,
+      eslintPluginPrettierRecommended,
+    },
+    rules: {
+      quotes: ['error', 'single', { avoidEscape: true }],
+    },
+  },
+];

package/lib/clauseEvaluator.d.ts

@@ -0,0 +1,22 @@
+import { Clause } from './proto/feature/clause_pb';
+import { SegmentUser } from './proto/feature/segment_pb';
+declare class ClauseEvaluator {
+    private segmentEvaluator;
+    private dependencyEvaluator;
+    constructor();
+    evaluate(targetValue: string, clause: Clause, userID: string, segmentUsers: SegmentUser[], flagVariations: {
+        [key: string]: string;
+    }): boolean;
+    private equals;
+    private partiallyMatches;
+    private in;
+    private startsWith;
+    private endsWith;
+    private greater;
+    private greaterOrEqual;
+    private less;
+    private lessOrEqual;
+    private before;
+    private after;
+}
+export { ClauseEvaluator };

package/lib/clauseEvaluator.js

@@ -0,0 +1,299 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var __createBinding = void 0 && (void 0).__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 get() {
+        return m[k];
+      }
+    };
+  }
+  Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+var __setModuleDefault = void 0 && (void 0).__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
+var __importStar = void 0 && (void 0).__importStar || function (mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+  __setModuleDefault(result, mod);
+  return result;
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClauseEvaluator = void 0;
+var clause_pb_1 = require("./proto/feature/clause_pb");
+var segmentEvaluator_1 = require("./segmentEvaluator");
+var dependencyEvaluator_1 = require("./dependencyEvaluator");
+var semver = __importStar(require("semver"));
+//
+var ClauseEvaluator = /*#__PURE__*/function () {
+  function ClauseEvaluator() {
+    _classCallCheck(this, ClauseEvaluator);
+    _defineProperty(this, "segmentEvaluator", void 0);
+    _defineProperty(this, "dependencyEvaluator", void 0);
+    this.segmentEvaluator = new segmentEvaluator_1.SegmentEvaluator();
+    this.dependencyEvaluator = new dependencyEvaluator_1.DependencyEvaluator();
+  }
+  return _createClass(ClauseEvaluator, [{
+    key: "evaluate",
+    value: function evaluate(targetValue, clause, userID, segmentUsers, flagVariations) {
+      try {
+        switch (clause.getOperator()) {
+          case clause_pb_1.Clause.Operator.EQUALS:
+            return this.equals(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.IN:
+            return this["in"](targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.STARTS_WITH:
+            return this.startsWith(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.ENDS_WITH:
+            return this.endsWith(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.SEGMENT:
+            return this.segmentEvaluator.evaluate(clause.getValuesList(), userID, segmentUsers);
+          case clause_pb_1.Clause.Operator.GREATER:
+            return this.greater(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.GREATER_OR_EQUAL:
+            return this.greaterOrEqual(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.LESS:
+            return this.less(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.LESS_OR_EQUAL:
+            return this.lessOrEqual(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.BEFORE:
+            return this.before(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.AFTER:
+            return this.after(targetValue, clause.getValuesList());
+          case clause_pb_1.Clause.Operator.FEATURE_FLAG:
+            return this.dependencyEvaluator.evaluate(clause.getAttribute(), clause.getValuesList(), flagVariations);
+          case clause_pb_1.Clause.Operator.PARTIALLY_MATCH:
+            return this.partiallyMatches(targetValue, clause.getValuesList());
+          default:
+            return false;
+        }
+      } catch (error) {
+        console.error('Error evaluating clause:', error);
+        throw error;
+      }
+    }
+  }, {
+    key: "equals",
+    value: function equals(targetValue, values) {
+      return values.includes(targetValue);
+    }
+  }, {
+    key: "partiallyMatches",
+    value: function partiallyMatches(targetValue, values) {
+      return values.some(function (value) {
+        return targetValue.includes(value);
+      });
+    }
+  }, {
+    key: "in",
+    value: function _in(targetValue, values) {
+      return values.includes(targetValue);
+    }
+  }, {
+    key: "startsWith",
+    value: function startsWith(targetValue, values) {
+      return values.some(function (value) {
+        return targetValue.startsWith(value);
+      });
+    }
+  }, {
+    key: "endsWith",
+    value: function endsWith(targetValue, values) {
+      return values.some(function (value) {
+        return targetValue.endsWith(value);
+      });
+    }
+  }, {
+    key: "greater",
+    value: function greater(targetValue, values) {
+      var floatTarget = validateAndParseFloat(targetValue);
+      var floatValues = values.map(validateAndParseFloat).filter(function (value) {
+        return !isNaN(value);
+      });
+      if (!isNaN(floatTarget)) {
+        if (floatValues.length == 0) {
+          return false;
+        }
+        return floatValues.some(function (value) {
+          return floatTarget > value;
+        });
+      }
+      var semverTarget = semver.valid(targetValue);
+      if (semverTarget) {
+        return values.some(function (value) {
+          if (semver.valid(value)) {
+            return semver.gt(semverTarget, value);
+          }
+          return false;
+        });
+      }
+      return values.some(function (value) {
+        return targetValue > value;
+      });
+    }
+  }, {
+    key: "greaterOrEqual",
+    value: function greaterOrEqual(targetValue, values) {
+      var floatTarget = validateAndParseFloat(targetValue);
+      var floatValues = values.map(validateAndParseFloat).filter(function (value) {
+        return !isNaN(value);
+      });
+      if (!isNaN(floatTarget)) {
+        if (floatValues.length == 0) {
+          return false;
+        }
+        return floatValues.some(function (value) {
+          return floatTarget >= value;
+        });
+      }
+      var semverTarget = semver.valid(targetValue);
+      if (semverTarget) {
+        return values.some(function (value) {
+          if (semver.valid(value)) {
+            return semver.gte(semverTarget, value);
+          }
+          return false;
+        });
+      }
+      return values.some(function (value) {
+        return targetValue >= value;
+      });
+    }
+  }, {
+    key: "less",
+    value: function less(targetValue, values) {
+      var floatTarget = validateAndParseFloat(targetValue);
+      var floatValues = values.map(validateAndParseFloat).filter(function (value) {
+        return !isNaN(value);
+      });
+      if (!isNaN(floatTarget)) {
+        if (floatValues.length == 0) {
+          return false;
+        }
+        return floatValues.some(function (value) {
+          return floatTarget < value;
+        });
+      }
+      var semverTarget = semver.valid(targetValue);
+      if (semverTarget) {
+        return values.some(function (value) {
+          if (semver.valid(value)) {
+            return semver.lt(semverTarget, value);
+          }
+          return false;
+        });
+      }
+      return values.some(function (value) {
+        return targetValue < value;
+      });
+    }
+  }, {
+    key: "lessOrEqual",
+    value: function lessOrEqual(targetValue, values) {
+      var floatTarget = validateAndParseFloat(targetValue);
+      var floatValues = values.map(validateAndParseFloat).filter(function (value) {
+        return !isNaN(value);
+      });
+      if (!isNaN(floatTarget)) {
+        if (floatValues.length == 0) {
+          return false;
+        }
+        return floatValues.some(function (value) {
+          return floatTarget <= value;
+        });
+      }
+      var semverTarget = semver.valid(targetValue);
+      if (semverTarget) {
+        return values.some(function (value) {
+          if (semver.valid(value)) {
+            return semver.lte(semverTarget, value);
+          }
+          return false;
+        });
+      }
+      return values.some(function (value) {
+        return targetValue <= value;
+      });
+    }
+  }, {
+    key: "before",
+    value: function before(targetValue, values) {
+      var intTarget = validateAndParseInt(targetValue);
+      if (isNaN(intTarget)) {
+        return false;
+      }
+      var intValues = values.map(function (value) {
+        return parseInt(value, 10);
+      }).filter(function (value) {
+        return !isNaN(value);
+      });
+      if (intValues.length == 0) {
+        return false;
+      }
+      return intValues.some(function (value) {
+        return intTarget < value;
+      });
+    }
+  }, {
+    key: "after",
+    value: function after(targetValue, values) {
+      var intTarget = parseInt(targetValue, 10);
+      var intValues = values.map(function (value) {
+        return parseInt(value, 10);
+      }).filter(function (value) {
+        return !isNaN(value);
+      });
+      return intValues.some(function (value) {
+        return intTarget > value;
+      });
+    }
+  }]);
+}();
+exports.ClauseEvaluator = ClauseEvaluator;
+function isNumericString(input) {
+  return /^-?\d*\.?\d+$/.test(input);
+}
+function validateAndParseInt(input) {
+  // Check if the string is a valid number using regex
+  if (!isNumericString(input)) {
+    // Will not allow a string like `1a`, `0b`
+    return NaN;
+  }
+  // Parse the string to float
+  var result = parseInt(input, 10);
+  // If parsing fails, return NaN
+  return isNaN(result) ? NaN : result;
+}
+function validateAndParseFloat(input) {
+  // Check if the string is a valid number using regex
+  if (!isNumericString(input)) {
+    // Will not allow a string like `1a`, `0b`
+    return NaN;
+  }
+  // Parse the string to float
+  var result = parseFloat(input);
+  // If parsing fails, return NaN
+  return isNaN(result) ? NaN : result;
+}

package/lib/clauseEvaluator.mjs

@@ -0,0 +1,214 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClauseEvaluator = void 0;
+const clause_pb_1 = require("./proto/feature/clause_pb");
+const segmentEvaluator_1 = require("./segmentEvaluator");
+const dependencyEvaluator_1 = require("./dependencyEvaluator");
+const semver = __importStar(require("semver"));
+//
+class ClauseEvaluator {
+    segmentEvaluator;
+    dependencyEvaluator;
+    constructor() {
+        this.segmentEvaluator = new segmentEvaluator_1.SegmentEvaluator();
+        this.dependencyEvaluator = new dependencyEvaluator_1.DependencyEvaluator();
+    }
+    evaluate(targetValue, clause, userID, segmentUsers, flagVariations) {
+        try {
+            switch (clause.getOperator()) {
+                case clause_pb_1.Clause.Operator.EQUALS:
+                    return this.equals(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.IN:
+                    return this.in(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.STARTS_WITH:
+                    return this.startsWith(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.ENDS_WITH:
+                    return this.endsWith(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.SEGMENT:
+                    return this.segmentEvaluator.evaluate(clause.getValuesList(), userID, segmentUsers);
+                case clause_pb_1.Clause.Operator.GREATER:
+                    return this.greater(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.GREATER_OR_EQUAL:
+                    return this.greaterOrEqual(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.LESS:
+                    return this.less(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.LESS_OR_EQUAL:
+                    return this.lessOrEqual(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.BEFORE:
+                    return this.before(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.AFTER:
+                    return this.after(targetValue, clause.getValuesList());
+                case clause_pb_1.Clause.Operator.FEATURE_FLAG:
+                    return this.dependencyEvaluator.evaluate(clause.getAttribute(), clause.getValuesList(), flagVariations);
+                case clause_pb_1.Clause.Operator.PARTIALLY_MATCH:
+                    return this.partiallyMatches(targetValue, clause.getValuesList());
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            console.error('Error evaluating clause:', error);
+            throw error;
+        }
+    }
+    equals(targetValue, values) {
+        return values.includes(targetValue);
+    }
+    partiallyMatches(targetValue, values) {
+        return values.some((value) => targetValue.includes(value));
+    }
+    in(targetValue, values) {
+        return values.includes(targetValue);
+    }
+    startsWith(targetValue, values) {
+        return values.some((value) => targetValue.startsWith(value));
+    }
+    endsWith(targetValue, values) {
+        return values.some((value) => targetValue.endsWith(value));
+    }
+    greater(targetValue, values) {
+        const floatTarget = validateAndParseFloat(targetValue);
+        const floatValues = values.map(validateAndParseFloat).filter((value) => !isNaN(value));
+        if (!isNaN(floatTarget)) {
+            if (floatValues.length == 0) {
+                return false;
+            }
+            return floatValues.some((value) => floatTarget > value);
+        }
+        const semverTarget = semver.valid(targetValue);
+        if (semverTarget) {
+            return values.some((value) => {
+                if (semver.valid(value)) {
+                    return semver.gt(semverTarget, value);
+                }
+                return false;
+            });
+        }
+        return values.some((value) => targetValue > value);
+    }
+    greaterOrEqual(targetValue, values) {
+        const floatTarget = validateAndParseFloat(targetValue);
+        const floatValues = values.map(validateAndParseFloat).filter((value) => !isNaN(value));
+        if (!isNaN(floatTarget)) {
+            if (floatValues.length == 0) {
+                return false;
+            }
+            return floatValues.some((value) => floatTarget >= value);
+        }
+        const semverTarget = semver.valid(targetValue);
+        if (semverTarget) {
+            return values.some((value) => {
+                if (semver.valid(value)) {
+                    return semver.gte(semverTarget, value);
+                }
+                return false;
+            });
+        }
+        return values.some((value) => targetValue >= value);
+    }
+    less(targetValue, values) {
+        const floatTarget = validateAndParseFloat(targetValue);
+        const floatValues = values.map(validateAndParseFloat).filter((value) => !isNaN(value));
+        if (!isNaN(floatTarget)) {
+            if (floatValues.length == 0) {
+                return false;
+            }
+            return floatValues.some((value) => floatTarget < value);
+        }
+        const semverTarget = semver.valid(targetValue);
+        if (semverTarget) {
+            return values.some((value) => {
+                if (semver.valid(value)) {
+                    return semver.lt(semverTarget, value);
+                }
+                return false;
+            });
+        }
+        return values.some((value) => targetValue < value);
+    }
+    lessOrEqual(targetValue, values) {
+        const floatTarget = validateAndParseFloat(targetValue);
+        const floatValues = values.map(validateAndParseFloat).filter((value) => !isNaN(value));
+        if (!isNaN(floatTarget)) {
+            if (floatValues.length == 0) {
+                return false;
+            }
+            return floatValues.some((value) => floatTarget <= value);
+        }
+        const semverTarget = semver.valid(targetValue);
+        if (semverTarget) {
+            return values.some((value) => {
+                if (semver.valid(value)) {
+                    return semver.lte(semverTarget, value);
+                }
+                return false;
+            });
+        }
+        return values.some((value) => targetValue <= value);
+    }
+    before(targetValue, values) {
+        const intTarget = validateAndParseInt(targetValue);
+        if (isNaN(intTarget)) {
+            return false;
+        }
+        const intValues = values.map((value) => parseInt(value, 10)).filter((value) => !isNaN(value));
+        if (intValues.length == 0) {
+            return false;
+        }
+        return intValues.some((value) => intTarget < value);
+    }
+    after(targetValue, values) {
+        const intTarget = parseInt(targetValue, 10);
+        const intValues = values.map((value) => parseInt(value, 10)).filter((value) => !isNaN(value));
+        return intValues.some((value) => intTarget > value);
+    }
+}
+exports.ClauseEvaluator = ClauseEvaluator;
+function isNumericString(input) {
+    return /^-?\d*\.?\d+$/.test(input);
+}
+function validateAndParseInt(input) {
+    // Check if the string is a valid number using regex
+    if (!isNumericString(input)) {
+        // Will not allow a string like `1a`, `0b`
+        return NaN;
+    }
+    // Parse the string to float
+    const result = parseInt(input, 10);
+    // If parsing fails, return NaN
+    return isNaN(result) ? NaN : result;
+}
+function validateAndParseFloat(input) {
+    // Check if the string is a valid number using regex
+    if (!isNumericString(input)) {
+        // Will not allow a string like `1a`, `0b`
+        return NaN;
+    }
+    // Parse the string to float
+    const result = parseFloat(input);
+    // If parsing fails, return NaN
+    return isNaN(result) ? NaN : result;
+}

package/lib/dependencyEvaluator.d.ts

@@ -0,0 +1,6 @@
+declare class DependencyEvaluator {
+    evaluate(featureID: string, variationIDs: string[], flagVariations: {
+        [key: string]: string;
+    }): boolean;
+}
+export { DependencyEvaluator };

package/lib/dependencyEvaluator.js

@@ -0,0 +1,46 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DependencyEvaluator = void 0;
+var errors_1 = require("./errors");
+var DependencyEvaluator = /*#__PURE__*/function () {
+  function DependencyEvaluator() {
+    _classCallCheck(this, DependencyEvaluator);
+  }
+  return _createClass(DependencyEvaluator, [{
+    key: "evaluate",
+    value: function evaluate(featureID, variationIDs, flagVariations) {
+      var targetVarID = flagVariations[featureID];
+      if (!targetVarID) {
+        throw errors_1.EVALUATOR_ERRORS.FeatureNotFound; // Throwing an error if feature is not found
+      }
+      var _iterator = _createForOfIteratorHelper(variationIDs),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var varID = _step.value;
+          if (varID === targetVarID) {
+            return true; // Match found
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return false; // No match found
+    }
+  }]);
+}();
+exports.DependencyEvaluator = DependencyEvaluator;

package/lib/dependencyEvaluator.mjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyEvaluator = void 0;
+const errors_1 = require("./errors");
+class DependencyEvaluator {
+    evaluate(featureID, variationIDs, flagVariations) {
+        const targetVarID = flagVariations[featureID];
+        if (!targetVarID) {
+            throw errors_1.EVALUATOR_ERRORS.FeatureNotFound; // Throwing an error if feature is not found
+        }
+        for (const varID of variationIDs) {
+            if (varID === targetVarID) {
+                return true; // Match found
+            }
+        }
+        return false; // No match found
+    }
+}
+exports.DependencyEvaluator = DependencyEvaluator;

package/lib/errors.d.ts

@@ -0,0 +1,9 @@
+declare const EVALUATOR_ERRORS: {
+    StrategyNotFound: Error;
+    DefaultStrategyNotFound: Error;
+    FeatureNotFound: Error;
+    PrerequisiteVariationNotFound: Error;
+    VariationNotFound: Error;
+    UnsupportedStrategy: Error;
+};
+export { EVALUATOR_ERRORS };

package/lib/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EVALUATOR_ERRORS = void 0;
+var EVALUATOR_ERRORS = {
+  StrategyNotFound: new Error('evaluator: strategy not found'),
+  DefaultStrategyNotFound: new Error('evaluator: default strategy not found'),
+  FeatureNotFound: new Error('evaluator: feature not found'),
+  PrerequisiteVariationNotFound: new Error('evaluator: prerequisite variation not found'),
+  VariationNotFound: new Error('evaluator: variation not found'),
+  UnsupportedStrategy: new Error('evaluator: unsupported strategy')
+};
+exports.EVALUATOR_ERRORS = EVALUATOR_ERRORS;