Update eval logic to be more streamlined

a11a8fe95624271d16ea879f916332fb45dc727f

Wolfsblvt <wolfsblvt@gmail.com>

Parents: 8ae7c2330a18952be82fac7c3bf26f803ae67754

public/scripts/variables.js+34 -30 Viewed

     const left = getOperand(args.a ?? args.left ?? args.first ?? args.x);
     const right = getOperand(args.b ?? args.right ?? args.second ?? args.y);
     const rule = args.rule ?? 'eq';
     return { a: left, b: right, rule };
+}
 /**
  * Evaluates a boolean comparison rule.
 - * @param {string} rule Boolean comparison rule
 + *
 + * @param {string?} rule Boolean comparison rule
  * @param {string|number} a The left operand
  * @param {string|number?} b The right operand
  * @returns {boolean} True if the rule yields true, false otherwise
  */
 export function evalBoolean(rule, a, b) {
 -    if (b === undefined && rule === 'eq') {
 +    // If right-hand side was not provided, whe just check if the left side is truthy
 -        // If right-hand side was not provided, whe just check if the left side is truthy
 +    if (b === undefined) {
 -        if (isTrueBoolean(String(a))) return true;
 +        switch (rule) {
 -        if (isFalseBoolean(String(a))) return false;
 +            case undefined:
 -        return !!a;
 +            case 'not':
 +                const resultOnTruthy = rule !== 'not';
 +                if (isTrueBoolean(String(a))) return resultOnTruthy;
 +                if (isFalseBoolean(String(a))) return !resultOnTruthy;
 +                return !!a ? resultOnTruthy : !resultOnTruthy;
 +            default:
 +                throw new Error(`Unknown boolean comparison rule for truthy check. If right-hand side is not provided, the rule must not provided or be "not". Provided: ${rule}`);
 +        }
+    }
 -    // Restore old behavior, where b cannot be undefined
 +    // If no rule was provided, we are implicitly using 'eq', as defined for the slash commands
     b = brule ??= 'eq';
     if (typeof a === 'number' && typeof b === 'number') {
         // only do numeric comparison if both operands are numbers

         const bNumber = Number(b);
         switch (rule) {
 -            case 'not':
 -                return !aNumber;
             case 'gt':
                 return aNumber > bNumber;
             case 'gte':

             case 'neq':
                 return aNumber !== bNumber;
             default:
                 toastr.errorthrow new Error('`Unknown boolean comparison rule for type number.' Accepted: gt, 'Invalidgte, command'lt, lte, eq, neq. Provided: ${rule}`);
 -                throw new Error('Invalid command.');
+        }
     } else {
 -        // otherwise do case-insensitive string comparsion, stringify non-strings
 -        let aString = (typeof a === 'string') ? a.toLowerCase() : JSON.stringify(a).toLowerCase();
 -        let bString = (typeof b === 'string') ? b.toLowerCase() : JSON.stringify(b).toLowerCase();
 -        switch (rule) {
 +    // otherwise do case-insensitive string comparsion, stringify non-strings
 -            case 'in':
 +    let aString = (typeof a === 'string') ? a.toLowerCase() : JSON.stringify(a).toLowerCase();
 -                return aString.includes(bString);
 +    let bString = (typeof b === 'string') ? b.toLowerCase() : JSON.stringify(b).toLowerCase();
 -            case 'nin':
++
 -                return !aString.includes(bString);
 +    switch (rule) {
                     case 'eqin':
 -                return aString === bString;
 +            return aString.includes(bString);
                     case 'neqnin':
 -                return aString !== bString;
 +            return !aString.includes(bString);
 -            default:
 +        case 'eq':
 -                toastr.error('Unknown boolean comparison rule for type string.', 'Invalid /if command');
 +            return aString === bString;
 -                throw new Error('Unknown boolean comparison rule for type string.');
 +        case 'neq':
 -        }
 +            return aString !== bString;
 +        default:
 +            throw new Error(`Unknown boolean comparison rule for type number. Accepted: in, nin, eq, neq. Provided: ${rule}`);
+    }
+}