perf: push targetingRuleConditionValuesTypesFromValues down

validSemver is super-slow, so having it on the hot path in
evaluateCondition adds a ton of overhead (as in, >50%).

Author: rasendubi

src/rules.ts

@@ -154,8 +154,6 @@ function evaluateRuleConditions(
 function evaluateCondition(subjectAttributes: Record<string, any>, condition: Condition): boolean {
   const value = subjectAttributes[condition.attribute];
 
-  const conditionValueType = targetingRuleConditionValuesTypesFromValues(condition.value);
-
   if (condition.operator === OperatorType.IS_NULL) {
     if (condition.value) {
       return value === null || value === undefined;
@@ -166,25 +164,25 @@ function evaluateCondition(subjectAttributes: Record<string, any>, condition: Co
   if (value != null) {
     switch (condition.operator) {
       case OperatorType.GTE:
-        if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, condition.value, semverGte);
-        }
-        return compareNumber(value, condition.value, (a, b) => a >= b);
       case OperatorType.GT:
-        if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, condition.value, semverGt);
-        }
-        return compareNumber(value, condition.value, (a, b) => a > b);
       case OperatorType.LTE:
-        if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, condition.value, semverLte);
-        }
-        return compareNumber(value, condition.value, (a, b) => a <= b);
       case OperatorType.LT:
+        const conditionValueType = targetingRuleConditionValuesTypesFromValues(condition.value);
         if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, condition.value, semverLt);
+          const comparator =
+            condition.operator === OperatorType.GTE ? semverGte :
+            condition.operator === OperatorType.GT ? semverGt :
+            condition.operator === OperatorType.LTE ? semverLte :
+            semverLt;
+          return compareSemVer(value, condition.value, comparator);
         }
-        return compareNumber(value, condition.value, (a, b) => a < b);
+
+        const comparator = (a: number, b: number) =>
+          condition.operator === OperatorType.GTE ? a >= b :
+          condition.operator === OperatorType.GT ? a > b :
+          condition.operator === OperatorType.LTE ? a <= b :
+          a < b;
+        return compareNumber(value, condition.value, comparator);
       case OperatorType.MATCHES:
         return new RegExp(condition.value as string).test(value as string);
       case OperatorType.NOT_MATCHES:
@@ -203,7 +201,6 @@ function evaluateObfuscatedCondition(
   condition: Condition,
 ): boolean {
   const value = hashedSubjectAttributes[condition.attribute];
-  const conditionValueType = targetingRuleConditionValuesTypesFromValues(value);
 
   if (condition.operator === ObfuscatedOperatorType.IS_NULL) {
     if (condition.value === getMD5Hash('true')) {
@@ -215,40 +212,29 @@ function evaluateObfuscatedCondition(
   if (value != null) {
     switch (condition.operator) {
       case ObfuscatedOperatorType.GTE:
-        if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, decodeBase64(condition.value as string), semverGte);
-        }
-        return compareNumber(
-          value,
-          Number(decodeBase64(condition.value as string)),
-          (a, b) => a >= b,
-        );
       case ObfuscatedOperatorType.GT:
-        if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, decodeBase64(condition.value as string), semverGt);
-        }
-        return compareNumber(
-          value,
-          Number(decodeBase64(condition.value as string)),
-          (a, b) => a > b,
-        );
       case ObfuscatedOperatorType.LTE:
-        if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, decodeBase64(condition.value as string), semverLte);
-        }
-        return compareNumber(
-          value,
-          Number(decodeBase64(condition.value as string)),
-          (a, b) => a <= b,
-        );
       case ObfuscatedOperatorType.LT:
+        const conditionValue = decodeBase64(condition.value);
+        const conditionValueType = targetingRuleConditionValuesTypesFromValues(conditionValue);
         if (conditionValueType === OperatorValueType.SEM_VER) {
-          return compareSemVer(value, decodeBase64(condition.value as string), semverLt);
+          const comparator =
+            condition.operator === ObfuscatedOperatorType.GTE ? semverGte :
+            condition.operator === ObfuscatedOperatorType.GT ? semverGt :
+            condition.operator === ObfuscatedOperatorType.LTE ? semverLte :
+            semverLt;
+          return compareSemVer(value, conditionValue, comparator);
         }
+
+        const comparator = (a: number, b: number) =>
+          condition.operator === ObfuscatedOperatorType.GTE ? a >= b :
+          condition.operator === ObfuscatedOperatorType.GT ? a > b :
+          condition.operator === ObfuscatedOperatorType.LTE ? a <= b :
+          a < b;
         return compareNumber(
           value,
-          Number(decodeBase64(condition.value as string)),
-          (a, b) => a < b,
+          Number(conditionValue),
+          comparator,
         );
       case ObfuscatedOperatorType.MATCHES:
         return new RegExp(decodeBase64(condition.value as string)).test(value as string);