Translate VisualBasic expressions to JavaScript expressions dynamically

According to the tasks that need to be processed, all you need is a compiler. That need to convert the vb program to ast first, then traverse the ast, and convert the ast to the js code, just like babel does. The following link is an example In addition, here is a third-party library that can be used. https://github.com/zaach/jison

Or use a hacky way, all functions return an object property, the property sets a setter, when assigning a value, the value is assigned to the specified field, and finally a js function named IF will process each parameter value .

You can try using some PEG parser generator like PEG.js because it's easier to write grammars in PEG.

Here is a sample PEG.js grammar which implements an expression parser that can parse a subset of some VB expressions (not tested too much):

// All operators in VBA are left-associative (incl. power)
// Precedence from https://docs.microsoft.com/en-us/office/vba/language/reference/user-interface-help/operator-precedence

Expr = Logical1

Logical1 = left:Logical2 t:(_ op:OperOr right:Logical2      { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }
    
Logical2 = left:Logical3 t:(_ op:'And'i right:Logical3      { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }
    
Logical3 = op:'Not'i right:Logical3                         { return { kind: "unop", op, right } }
    / Comp

Comp = left:Arith1 t:(_ op:OperComp right:Arith1            { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }

Arith1 = left:Arith2 t:(_ op:[&] right:Arith2               { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }
    
Arith2 = left:Arith3 t:(_ op:[+-] right:Arith3              { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }
    
Arith3 = left:Arith4 t:(_ op:'Mod'i right:Arith4            { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }
    
Arith4 = left:Arith5 t:(_ op:[\\] right:Arith5              { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }
    
Arith5 = left:Arith6 t:(_ op:[*/] right:Arith6              { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }
    
Arith6 = op:[+-] !(_ Number) right:Arith6                   { return { kind: "unop", op, right } }
    / Arith7
    
Arith7 = left:Primary t:(_ op:[\^] right:Primary            { return { op, right } }
    )* { return t.reduce((a, e) =>                          { return { kind: "binop", left:a, op:e.op, right:e.right } }, left) }

Primary = _ id:Ident _ '(' params:Params _ ')'              { return { kind: "call", id, params } }
    / _ id:Ident                                            { return { kind: "var", id } }
    / _ n:Number                                            { return n }
    / _ s:String                                            { return s }
    / _ '(' e:Expr _ ')'                                    { return e }

Params = p:Expr _ ',' r:Params                              { return [p].concat(r) }
    / e:Expr                                                { return [e] }
    / _                                                     { return [] }

// Lexical rules

OperOr = 'Or'i / 'Xor'i / 'Eqv'i / 'Imp'i
OperComp = '<=' / '=>' / '<>' / [<>=] / 'Like'i / 'Is'i
Ident = [A-Za-z_][A-Za-z0-9_]*                              { return text() }
String = '"' s:('""' / [^"])* '"'                           { return s.join("").replace('""', '"') }
Number = ([+-] _)? Int ('.' Int?)? ([Ee] [+-]? Int)?        { return Number(text()) }
Int = [0-9]+
_ = [ \t\r\n]*

This will parse your IF(RECORD_NR() = -1, "NR,1",IF(RECORD_NR() = 2, "NR,2", "NR3")) into a parse tree like this:

{
   "kind": "call",
   "id": "IF",
   "params": [
      {
         "kind": "binop",
         "left": {
            "kind": "call",
            "id": "RECORD_NR",
            "params": []
         },
         "op": "=",
         "right": -1
      },
      "NR,1",
      {
         "kind": "call",
         "id": "IF",
         "params": [
            {
               "kind": "binop",
               "left": {
                  "kind": "call",
                  "id": "RECORD_NR",
                  "params": []
               },
               "op": "=",
               "right": 2
            },
            "NR,2",
            "NR3"
         ]
      }
   ]
}

Traversing such parse tree and emitting appropriate JS code to evaluate the expression is up to you.

You can fiddle with the grammar above online in the PEG.js playground at https://pegjs.org/online