jprx 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jprx",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "description": "JSON Reactive Path eXpressions - A reactive expression language for JSON data",
     "main": "index.js",
     "type": "module",

package/parser.js

@@ -487,16 +487,17 @@ const tokenize = (expr) => {
         // In expressions like "$++/count", the $ is just the JPRX delimiter
         // and ++ is a prefix operator applied to /count
         if (expr[i] === '$' && i + 1 < len) {
-            // Check if next chars are an operator
-            let isOpAfter = false;
-            for (const op of opSymbols) {
+            // Check if next chars are a PREFIX operator (sort by length to match longest first)
+            const prefixOps = [...operators.prefix.keys()].sort((a, b) => b.length - a.length);
+            let isPrefixOp = false;
+            for (const op of prefixOps) {
                 if (expr.slice(i + 1, i + 1 + op.length) === op) {
-                    isOpAfter = true;
+                    isPrefixOp = true;
                     break;
                 }
             }
-            if (isOpAfter) {
-                // Skip the $, it's just a delimiter
+            if (isPrefixOp) {
+                // Skip the $, it's just a delimiter for a prefix operator (e.g., $++/count)
                 i++;
                 continue;
             }
@@ -814,7 +815,7 @@ class PrattParser {
             const prec = this.getInfixPrecedence(tok.value);
             if (prec < minPrecedence) break;
 
-            // Check if it's a postfix operator
+            // Check if it's a postfix-only operator
             if (operators.postfix.has(tok.value) && !operators.infix.has(tok.value)) {
                 this.consume();
                 left = { type: 'Postfix', operator: tok.value, operand: left };
@@ -832,6 +833,12 @@ class PrattParser {
                 continue;
             }
 
+            // Operator not registered as postfix or infix - treat as unknown and stop
+            // This prevents infinite loops when operators are tokenized but not registered
+            if (!operators.postfix.has(tok.value) && !operators.infix.has(tok.value)) {
+                break;
+            }
+
             // Postfix that's also infix - context determines
             // If next token is a value, treat as infix
             this.consume();
@@ -1019,7 +1026,18 @@ const evaluateAST = (ast, context, forMutation = false) => {
             // For infix, typically first arg might be pathAware
             const left = evaluateAST(ast.left, context, opts.pathAware);
             const right = evaluateAST(ast.right, context, false);
-            return helper(unwrapSignal(left), unwrapSignal(right));
+
+            const finalArgs = [];
+
+            // Handle potentially exploded arguments (like in sum(/items...p))
+            // Although infix operators usually take exactly 2 args, we treat them consistently
+            if (Array.isArray(left) && ast.left.type === 'Explosion') finalArgs.push(...left);
+            else finalArgs.push(unwrapSignal(left));
+
+            if (Array.isArray(right) && ast.right.type === 'Explosion') finalArgs.push(...right);
+            else finalArgs.push(unwrapSignal(right));
+
+            return helper(...finalArgs);
         }
 
         default:

package/specs/expressions.json

@@ -0,0 +1,71 @@
+[
+    {
+        "name": "Global Path Resolution",
+        "state": {
+            "userName": "Alice"
+        },
+        "expression": "$/userName",
+        "expected": "Alice"
+    },
+    {
+        "name": "Deep Global Path Resolution",
+        "state": {
+            "user": {
+                "profile": {
+                    "name": "Bob"
+                }
+            }
+        },
+        "expression": "$/user/profile/name",
+        "expected": "Bob"
+    },
+    {
+        "name": "Relative Path Resolution",
+        "context": {
+            "age": 30
+        },
+        "expression": "./age",
+        "expected": 30
+    },
+    {
+        "name": "Math: Addition",
+        "state": {
+            "a": 5,
+            "b": 10
+        },
+        "expression": "$+(/a, /b)",
+        "expected": 15
+    },
+    {
+        "name": "Operator: Addition (Infix)",
+        "state": {
+            "a": 5,
+            "b": 10
+        },
+        "expression": "$/a + $/b",
+        "expected": 15
+    },
+    {
+        "name": "Logic: If (True)",
+        "state": {
+            "isVip": true
+        },
+        "expression": "$if(/isVip, \"Gold\", \"Silver\")",
+        "expected": "Gold"
+    },
+    {
+        "name": "Explosion Operator",
+        "state": {
+            "items": [
+                {
+                    "p": 10
+                },
+                {
+                    "p": 20
+                }
+            ]
+        },
+        "expression": "$sum(/items...p)",
+        "expected": 30
+    }
+]

package/specs/helpers.json

@@ -0,0 +1,150 @@
+[
+    {
+        "name": "Math: Subtraction",
+        "expression": "$-(10, 3)",
+        "expected": 7
+    },
+    {
+        "name": "Math: Multiplication",
+        "expression": "$*(4, 5)",
+        "expected": 20
+    },
+    {
+        "name": "Math: Division",
+        "expression": "$/(20, 4)",
+        "expected": 5
+    },
+    {
+        "name": "Math: Round",
+        "expression": "$round(3.7)",
+        "expected": 4
+    },
+    {
+        "name": "String: Upper",
+        "expression": "$upper('hello')",
+        "expected": "HELLO"
+    },
+    {
+        "name": "String: Lower",
+        "expression": "$lower('WORLD')",
+        "expected": "world"
+    },
+    {
+        "name": "String: Concat",
+        "expression": "$concat('Hello', ' ', 'World')",
+        "expected": "Hello World"
+    },
+    {
+        "name": "String: Trim",
+        "expression": "$trim('  spaced  ')",
+        "expected": "spaced"
+    },
+    {
+        "name": "Logic: And (true)",
+        "expression": "$and(true, true)",
+        "expected": true
+    },
+    {
+        "name": "Logic: And (false)",
+        "expression": "$and(true, false)",
+        "expected": false
+    },
+    {
+        "name": "Logic: Or",
+        "expression": "$or(false, true)",
+        "expected": true
+    },
+    {
+        "name": "Logic: Not",
+        "expression": "$not(false)",
+        "expected": true
+    },
+    {
+        "name": "Compare: Greater Than",
+        "expression": "$gt(10, 5)",
+        "expected": true
+    },
+    {
+        "name": "Compare: Less Than",
+        "expression": "$lt(3, 7)",
+        "expected": true
+    },
+    {
+        "name": "Compare: Equal",
+        "expression": "$eq(5, 5)",
+        "expected": true
+    },
+    {
+        "name": "Conditional: If (true branch)",
+        "expression": "$if(true, 'Yes', 'No')",
+        "expected": "Yes"
+    },
+    {
+        "name": "Conditional: If (false branch)",
+        "expression": "$if(false, 'Yes', 'No')",
+        "expected": "No"
+    },
+    {
+        "name": "Stats: Average",
+        "expression": "$avg(10, 20, 30)",
+        "expected": 20
+    },
+    {
+        "name": "Stats: Min",
+        "expression": "$min(5, 2, 8)",
+        "expected": 2
+    },
+    {
+        "name": "Stats: Max",
+        "expression": "$max(5, 2, 8)",
+        "expected": 8
+    },
+    {
+        "name": "Array: Length",
+        "state": {
+            "items": [
+                "a",
+                "b",
+                "c"
+            ]
+        },
+        "expression": "$len(/items)",
+        "expected": 3
+    },
+    {
+        "name": "Array: Join",
+        "state": {
+            "items": [
+                "a",
+                "b",
+                "c"
+            ]
+        },
+        "expression": "$join(/items, '-')",
+        "expected": "a-b-c"
+    },
+    {
+        "name": "Array: First",
+        "state": {
+            "items": [
+                "a",
+                "b",
+                "c"
+            ]
+        },
+        "expression": "$first(/items)",
+        "expected": "a"
+    },
+    {
+        "name": "Array: Last",
+        "state": {
+            "items": [
+                "a",
+                "b",
+                "c"
+            ]
+        },
+        "expression": "$last(/items)",
+        "expected": "c"
+    }
+]