@airtasker/form-schema-compiler/lib/interpreter/evaluateBinaryExpression.js

a form schema compiler

"use strict";

exports.__esModule = true;
exports.evaluateNonBranchableBinaryExpression = undefined;

var _const = require("../const");

var handleRegex = function handleRegex(left, operator, right) {
  var regex = right instanceof RegExp ? right : new RegExp(right);

  if (left == null) {
    return regex.test("");
  }

  return regex.test(left);
};

var evaluateNonBranchableBinaryExpression = exports.evaluateNonBranchableBinaryExpression = function evaluateNonBranchableBinaryExpression(_ref) {
  var operator = _ref.operator,
      left = _ref.left,
      right = _ref.right;

  switch (operator) {
    case _const.OPERATORS.LessThan:
      return left < right;

    case _const.OPERATORS.LessThanOrEqualTo:
      return left <= right;

    case _const.OPERATORS.GreaterThan:
      return left > right;

    case _const.OPERATORS.GreaterThanOrEqualTo:
      return left >= right;

    case _const.OPERATORS.EqualTo:
      return left === right;

    case _const.OPERATORS.NotEqualTo:
      return left !== right;

    case _const.OPERATORS.Match:
      return handleRegex(left, operator, right);

    case _const.OPERATORS.Add:
      return left + right;

    case _const.OPERATORS.Subtract:
      return left - right;

    case _const.OPERATORS.Multiply:
      return left * right;

    case _const.OPERATORS.Divide:
      return left / right;

    case _const.OPERATORS.Remainder:
      return left % right;

    default:
      throw new Error("unknown binary expression: ".concat({
        operator: operator,
        left: left,
        right: right
      }));
  }
};

var evaluateBinaryExpression = function evaluateBinaryExpression(_ref2, env, evaluate) {
  var operator = _ref2.operator,
      left = _ref2.left,
      right = _ref2.right;

  switch (operator) {
    // specially handling for OR and AND
    case _const.OPERATORS.Or:
      // if left is true will ignore right
      return evaluate(left, env) || evaluate(right, env);

    case _const.OPERATORS.And:
      // if left is false will ignore right
      return evaluate(left, env) && evaluate(right, env);

    default:
      return evaluateNonBranchableBinaryExpression({
        operator: operator,
        left: evaluate(left, env),
        right: evaluate(right, env)
      });
  }
};

exports["default"] = evaluateBinaryExpression;