@kenji71089/evaluation 0.0.1

package/lib/protoc-gen-openapiv2/options/openapiv2_pb_service.d.ts

@@ -0,0 +1,3 @@
+// package: grpc.gateway.protoc_gen_openapiv2.options
+// file: protoc-gen-openapiv2/options/openapiv2.proto
+

package/lib/protoc-gen-openapiv2/options/openapiv2_pb_service.js

@@ -0,0 +1,3 @@
+// package: grpc.gateway.protoc_gen_openapiv2.options
+// file: protoc-gen-openapiv2/options/openapiv2.proto
+"use strict";

package/lib/protoc-gen-openapiv2/options/openapiv2_pb_service.mjs

@@ -0,0 +1,3 @@
+// package: grpc.gateway.protoc_gen_openapiv2.options
+// file: protoc-gen-openapiv2/options/openapiv2.proto
+

package/lib/ruleEvaluator.d.ts

@@ -0,0 +1,13 @@
+import { Rule } from './proto/feature/rule_pb';
+import { User } from './proto/user/user_pb';
+import { SegmentUser } from './proto/feature/segment_pb';
+declare class RuleEvaluator {
+    private clauseEvaluator;
+    constructor();
+    evaluate(rules: Rule[], user: User, segmentUsers: SegmentUser[], flagVariations: {
+        [key: string]: string;
+    }): Rule | null;
+    private evaluateRule;
+    private evaluateClause;
+}
+export { RuleEvaluator };

package/lib/ruleEvaluator.js

@@ -0,0 +1,80 @@
+"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 _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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RuleEvaluator = void 0;
+var clauseEvaluator_1 = require("./clauseEvaluator");
+//
+var RuleEvaluator = /*#__PURE__*/function () {
+  function RuleEvaluator() {
+    _classCallCheck(this, RuleEvaluator);
+    _defineProperty(this, "clauseEvaluator", void 0);
+    this.clauseEvaluator = new clauseEvaluator_1.ClauseEvaluator();
+  }
+  return _createClass(RuleEvaluator, [{
+    key: "evaluate",
+    value: function evaluate(rules, user, segmentUsers, flagVariations) {
+      var _iterator = _createForOfIteratorHelper(rules),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var rule = _step.value;
+          var matched = this.evaluateRule(rule, user, segmentUsers, flagVariations);
+          if (matched) {
+            return rule;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return null;
+    }
+  }, {
+    key: "evaluateRule",
+    value: function evaluateRule(rule, user, segmentUsers, flagVariations) {
+      var _iterator2 = _createForOfIteratorHelper(rule.getClausesList()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var clause = _step2.value;
+          var matched = this.evaluateClause(clause, user, segmentUsers, flagVariations);
+          if (!matched) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return true;
+    }
+  }, {
+    key: "evaluateClause",
+    value: function evaluateClause(clause, user, segmentUsers, flagVariations) {
+      var targetAttr;
+      if (clause.getAttribute() === 'id') {
+        targetAttr = user.getId();
+      } else {
+        targetAttr = user.getDataMap().get(clause.getAttribute());
+      }
+      return this.clauseEvaluator.evaluate(targetAttr || '',
+      // Handling the case where targetAttr is undefined
+      clause, user.getId(), segmentUsers, flagVariations);
+    }
+  }]);
+}();
+exports.RuleEvaluator = RuleEvaluator;

package/lib/ruleEvaluator.mjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleEvaluator = void 0;
+const clauseEvaluator_1 = require("./clauseEvaluator");
+//
+class RuleEvaluator {
+    clauseEvaluator;
+    constructor() {
+        this.clauseEvaluator = new clauseEvaluator_1.ClauseEvaluator();
+    }
+    evaluate(rules, user, segmentUsers, flagVariations) {
+        for (const rule of rules) {
+            const matched = this.evaluateRule(rule, user, segmentUsers, flagVariations);
+            if (matched) {
+                return rule;
+            }
+        }
+        return null;
+    }
+    evaluateRule(rule, user, segmentUsers, flagVariations) {
+        for (const clause of rule.getClausesList()) {
+            const matched = this.evaluateClause(clause, user, segmentUsers, flagVariations);
+            if (!matched) {
+                return false;
+            }
+        }
+        return true;
+    }
+    evaluateClause(clause, user, segmentUsers, flagVariations) {
+        let targetAttr;
+        if (clause.getAttribute() === 'id') {
+            targetAttr = user.getId();
+        }
+        else {
+            targetAttr = user.getDataMap().get(clause.getAttribute());
+        }
+        return this.clauseEvaluator.evaluate(targetAttr || '', // Handling the case where targetAttr is undefined
+        clause, user.getId(), segmentUsers, flagVariations);
+    }
+}
+exports.RuleEvaluator = RuleEvaluator;

package/lib/segmentEvaluator.d.ts

@@ -0,0 +1,7 @@
+import { SegmentUser } from './proto/feature/segment_pb';
+declare class SegmentEvaluator {
+    evaluate(segmentIDs: string[], userID: string, segmentUsers: SegmentUser[]): boolean;
+    private findSegmentUser;
+    private containsSegmentUser;
+}
+export { SegmentEvaluator };

package/lib/segmentEvaluator.js

@@ -0,0 +1,74 @@
+"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.SegmentEvaluator = void 0;
+var segment_pb_1 = require("./proto/feature/segment_pb");
+//
+var SegmentEvaluator = /*#__PURE__*/function () {
+  function SegmentEvaluator() {
+    _classCallCheck(this, SegmentEvaluator);
+  }
+  return _createClass(SegmentEvaluator, [{
+    key: "evaluate",
+    value: function evaluate(segmentIDs, userID, segmentUsers) {
+      return this.findSegmentUser(segmentIDs, userID, segment_pb_1.SegmentUser.State.INCLUDED, segmentUsers);
+    }
+  }, {
+    key: "findSegmentUser",
+    value: function findSegmentUser(segmentIDs, userID, state, segmentUsers) {
+      var _iterator = _createForOfIteratorHelper(segmentIDs),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var segmentID = _step.value;
+          if (!this.containsSegmentUser(segmentID, userID, state, segmentUsers)) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return true;
+    }
+  }, {
+    key: "containsSegmentUser",
+    value: function containsSegmentUser(segmentID, userID, state, segmentUsers) {
+      var _iterator2 = _createForOfIteratorHelper(segmentUsers),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var user = _step2.value;
+          if (user.getSegmentId() !== segmentID) {
+            continue;
+          }
+          if (user.getUserId() !== userID) {
+            continue;
+          }
+          if (user.getState() !== state) {
+            continue;
+          }
+          return true;
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return false;
+    }
+  }]);
+}();
+exports.SegmentEvaluator = SegmentEvaluator;

package/lib/segmentEvaluator.mjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentEvaluator = void 0;
+const segment_pb_1 = require("./proto/feature/segment_pb");
+//
+class SegmentEvaluator {
+    evaluate(segmentIDs, userID, segmentUsers) {
+        return this.findSegmentUser(segmentIDs, userID, segment_pb_1.SegmentUser.State.INCLUDED, segmentUsers);
+    }
+    findSegmentUser(segmentIDs, userID, state, segmentUsers) {
+        for (const segmentID of segmentIDs) {
+            if (!this.containsSegmentUser(segmentID, userID, state, segmentUsers)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    containsSegmentUser(segmentID, userID, state, segmentUsers) {
+        for (const user of segmentUsers) {
+            if (user.getSegmentId() !== segmentID) {
+                continue;
+            }
+            if (user.getUserId() !== userID) {
+                continue;
+            }
+            if (user.getState() !== state) {
+                continue;
+            }
+            return true;
+        }
+        return false;
+    }
+}
+exports.SegmentEvaluator = SegmentEvaluator;

package/lib/strategyEvaluator.d.ts

@@ -0,0 +1,10 @@
+import { Strategy } from './proto/feature/strategy_pb';
+import { Variation } from './proto/feature/variation_pb';
+declare class StrategyEvaluator {
+    evaluate(strategy: Strategy, userID: string, variations: Variation[], featureID: string, samplingSeed: string): Variation;
+    private rollout;
+    private bucket;
+    private hash;
+    private findVariation;
+}
+export { StrategyEvaluator };

package/lib/strategyEvaluator.js

@@ -0,0 +1,135 @@
+"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); }
+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.StrategyEvaluator = void 0;
+var crypto = __importStar(require("crypto"));
+var strategy_pb_1 = require("./proto/feature/strategy_pb");
+//
+var MAX = 0xffffffffffffffffn;
+var StrategyEvaluator = /*#__PURE__*/function () {
+  function StrategyEvaluator() {
+    _classCallCheck(this, StrategyEvaluator);
+  }
+  return _createClass(StrategyEvaluator, [{
+    key: "evaluate",
+    value: function evaluate(strategy, userID, variations, featureID, samplingSeed) {
+      var _strategy$getFixedStr;
+      switch (strategy.getType()) {
+        case strategy_pb_1.Strategy.Type.FIXED:
+          return this.findVariation(((_strategy$getFixedStr = strategy.getFixedStrategy()) === null || _strategy$getFixedStr === void 0 ? void 0 : _strategy$getFixedStr.getVariation()) || '', variations);
+        case strategy_pb_1.Strategy.Type.ROLLOUT:
+          var rolloutStrategy = strategy.getRolloutStrategy();
+          if (rolloutStrategy !== undefined) {
+            var variationID = this.rollout(rolloutStrategy, userID, featureID, samplingSeed);
+            return this.findVariation(variationID, variations);
+          }
+          throw new Error('Missing rollout strategy');
+        default:
+          throw new Error('Unsupported strategy');
+      }
+    }
+  }, {
+    key: "rollout",
+    value: function rollout(strategy, userID, featureID, samplingSeed) {
+      var bucket = this.bucket(userID, featureID, samplingSeed);
+      var sum = 0.0;
+      var _iterator = _createForOfIteratorHelper(strategy.getVariationsList()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var variation = _step.value;
+          sum += variation.getWeight() / 100000.0;
+          if (bucket < sum) {
+            return variation.getVariation();
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      throw new Error('Variation not found');
+    }
+  }, {
+    key: "bucket",
+    value: function bucket(userID, featureID, samplingSeed) {
+      try {
+        var hash = this.hash(userID, featureID, samplingSeed);
+        var intVal = BigInt('0x' + hash.slice(0, 16)); // Convert the first 16 hex characters to BigInt
+        // Divide the BigInt value by `max` and convert it to a number. Use Number() since we need a float.
+        return Number(intVal) / Number(MAX);
+      } catch (error) {
+        console.error('Failed to calculate bucket value:', error);
+        throw error;
+      }
+    }
+  }, {
+    key: "hash",
+    value: function hash(userID, featureID, samplingSeed) {
+      var concat = "".concat(featureID, "-").concat(userID).concat(samplingSeed);
+      return crypto.createHash('md5').update(concat).digest('hex');
+    }
+  }, {
+    key: "findVariation",
+    value: function findVariation(variationID, variations) {
+      var _iterator2 = _createForOfIteratorHelper(variations),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var variation = _step2.value;
+          if (variation.getId() === variationID) {
+            return variation;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      throw new Error('Variation not found');
+    }
+  }]);
+}();
+exports.StrategyEvaluator = StrategyEvaluator;

package/lib/strategyEvaluator.mjs

@@ -0,0 +1,83 @@
+"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.StrategyEvaluator = void 0;
+const crypto = __importStar(require("crypto"));
+const strategy_pb_1 = require("./proto/feature/strategy_pb");
+//
+const MAX = 0xffffffffffffffffn;
+class StrategyEvaluator {
+    evaluate(strategy, userID, variations, featureID, samplingSeed) {
+        switch (strategy.getType()) {
+            case strategy_pb_1.Strategy.Type.FIXED:
+                return this.findVariation(strategy.getFixedStrategy()?.getVariation() || '', variations);
+            case strategy_pb_1.Strategy.Type.ROLLOUT:
+                const rolloutStrategy = strategy.getRolloutStrategy();
+                if (rolloutStrategy !== undefined) {
+                    const variationID = this.rollout(rolloutStrategy, userID, featureID, samplingSeed);
+                    return this.findVariation(variationID, variations);
+                }
+                throw new Error('Missing rollout strategy');
+            default:
+                throw new Error('Unsupported strategy');
+        }
+    }
+    rollout(strategy, userID, featureID, samplingSeed) {
+        const bucket = this.bucket(userID, featureID, samplingSeed);
+        let sum = 0.0;
+        for (const variation of strategy.getVariationsList()) {
+            sum += variation.getWeight() / 100000.0;
+            if (bucket < sum) {
+                return variation.getVariation();
+            }
+        }
+        throw new Error('Variation not found');
+    }
+    bucket(userID, featureID, samplingSeed) {
+        try {
+            const hash = this.hash(userID, featureID, samplingSeed);
+            const intVal = BigInt('0x' + hash.slice(0, 16)); // Convert the first 16 hex characters to BigInt
+            // Divide the BigInt value by `max` and convert it to a number. Use Number() since we need a float.
+            return Number(intVal) / Number(MAX);
+        }
+        catch (error) {
+            console.error('Failed to calculate bucket value:', error);
+            throw error;
+        }
+    }
+    hash(userID, featureID, samplingSeed) {
+        const concat = `${featureID}-${userID}${samplingSeed}`;
+        return crypto.createHash('md5').update(concat).digest('hex');
+    }
+    findVariation(variationID, variations) {
+        for (const variation of variations) {
+            if (variation.getId() === variationID) {
+                return variation;
+            }
+        }
+        throw new Error('Variation not found');
+    }
+}
+exports.StrategyEvaluator = StrategyEvaluator;

package/lib/userEvaluation.d.ts

@@ -0,0 +1,8 @@
+import { Evaluation, UserEvaluations } from './proto/feature/evaluation_pb';
+import { Feature } from './proto/feature/feature_pb';
+declare function NewUserEvaluations(id: string, evaluations: Evaluation[], archivedFeaturesIds: string[], forceUpdate: boolean): UserEvaluations;
+declare function sortMapKeys(data: Record<string, string>): string[];
+declare function GenerateFeaturesID(features: Feature[]): string;
+declare function UserEvaluationsID(userID: string, userMetadata: Record<string, string>, // equivalent to map[string]string in Go
+features: Feature[]): string;
+export { UserEvaluationsID, GenerateFeaturesID, sortMapKeys, NewUserEvaluations };

package/lib/userEvaluation.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UserEvaluationsID = UserEvaluationsID;
+exports.GenerateFeaturesID = GenerateFeaturesID;
+exports.sortMapKeys = sortMapKeys;
+exports.NewUserEvaluations = NewUserEvaluations;
+var evaluation_pb_1 = require("./proto/feature/evaluation_pb");
+var fnv_plus_1 = __importDefault(require("fnv-plus"));
+//
+function NewUserEvaluations(id, evaluations, archivedFeaturesIds, forceUpdate) {
+  var now = Math.floor(Date.now() / 1000); // Equivalent to Unix time
+  var userEvaluations = new evaluation_pb_1.UserEvaluations();
+  userEvaluations.setId(id);
+  userEvaluations.setEvaluationsList(evaluations);
+  userEvaluations.setCreatedAt(now);
+  userEvaluations.setArchivedFeatureIdsList(archivedFeaturesIds);
+  userEvaluations.setForceUpdate(forceUpdate);
+  return userEvaluations;
+}
+function sortMapKeys(data) {
+  var keys = Object.keys(data);
+  keys.sort(); // Sort keys alphabetically
+  return keys;
+}
+function GenerateFeaturesID(features) {
+  // Sort features based on the 'id'
+  features.sort(function (a, b) {
+    return a.getId() < b.getId() ? -1 : 1;
+  });
+  // Initialize FNV-1a 64-bit hash string
+  var hashInput = '';
+  // Concatenate each feature's 'id' and 'version' into the hash input
+  features.forEach(function (feature) {
+    hashInput += "".concat(feature.getId(), ":").concat(feature.getVersion());
+  });
+  // Generate the FNV-1a 64-bit hash and return it as a decimal string
+  var hash = fnv_plus_1["default"].hash(hashInput, 64);
+  return hash.dec();
+}
+function UserEvaluationsID(userID, userMetadata,
+// equivalent to map[string]string in Go
+features) {
+  // Sort features by ID
+  features.sort(function (a, b) {
+    return a.getId() < b.getId() ? -1 : 1;
+  });
+  // Initialize FNV-1a 64-bit hash input
+  var hashInput = userID;
+  // Sort and append userMetadata to the hash input
+  var keys = sortMapKeys(userMetadata);
+  keys.forEach(function (key) {
+    hashInput += "".concat(key, ":").concat(userMetadata[key]);
+  });
+  // Append feature details to the hash input
+  features.forEach(function (feature) {
+    hashInput += "".concat(feature.getId(), ":").concat(feature.getVersion());
+  });
+  // Generate the FNV-1a 64-bit hash
+  var hash = fnv_plus_1["default"].hash(hashInput, 64);
+  // Return the hashed value as a decimal string
+  return hash.dec();
+}

package/lib/userEvaluation.mjs

@@ -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.UserEvaluationsID = UserEvaluationsID;
+exports.GenerateFeaturesID = GenerateFeaturesID;
+exports.sortMapKeys = sortMapKeys;
+exports.NewUserEvaluations = NewUserEvaluations;
+const evaluation_pb_1 = require("./proto/feature/evaluation_pb");
+const fnv_plus_1 = __importDefault(require("fnv-plus"));
+//
+function NewUserEvaluations(id, evaluations, archivedFeaturesIds, forceUpdate) {
+    const now = Math.floor(Date.now() / 1000); // Equivalent to Unix time
+    const userEvaluations = new evaluation_pb_1.UserEvaluations();
+    userEvaluations.setId(id);
+    userEvaluations.setEvaluationsList(evaluations);
+    userEvaluations.setCreatedAt(now);
+    userEvaluations.setArchivedFeatureIdsList(archivedFeaturesIds);
+    userEvaluations.setForceUpdate(forceUpdate);
+    return userEvaluations;
+}
+function sortMapKeys(data) {
+    const keys = Object.keys(data);
+    keys.sort(); // Sort keys alphabetically
+    return keys;
+}
+function GenerateFeaturesID(features) {
+    // Sort features based on the 'id'
+    features.sort((a, b) => (a.getId() < b.getId() ? -1 : 1));
+    // Initialize FNV-1a 64-bit hash string
+    let hashInput = '';
+    // Concatenate each feature's 'id' and 'version' into the hash input
+    features.forEach((feature) => {
+        hashInput += `${feature.getId()}:${feature.getVersion()}`;
+    });
+    // Generate the FNV-1a 64-bit hash and return it as a decimal string
+    const hash = fnv_plus_1.default.hash(hashInput, 64);
+    return hash.dec();
+}
+function UserEvaluationsID(userID, userMetadata, // equivalent to map[string]string in Go
+features) {
+    // Sort features by ID
+    features.sort((a, b) => (a.getId() < b.getId() ? -1 : 1));
+    // Initialize FNV-1a 64-bit hash input
+    let hashInput = userID;
+    // Sort and append userMetadata to the hash input
+    const keys = sortMapKeys(userMetadata);
+    keys.forEach((key) => {
+        hashInput += `${key}:${userMetadata[key]}`;
+    });
+    // Append feature details to the hash input
+    features.forEach((feature) => {
+        hashInput += `${feature.getId()}:${feature.getVersion()}`;
+    });
+    // Generate the FNV-1a 64-bit hash
+    const hash = fnv_plus_1.default.hash(hashInput, 64);
+    // Return the hashed value as a decimal string
+    return hash.dec();
+}