lightview 2.2.2 → 2.3.4

package/jprx/parser.js

@@ -28,6 +28,9 @@ const DEFAULT_PRECEDENCE = {
  */
 export const registerHelper = (name, fn, options = {}) => {
     helpers.set(name, fn);
+    if (globalThis.__LIGHTVIEW_INTERNALS__) {
+        globalThis.__LIGHTVIEW_INTERNALS__.helpers.set(name, fn);
+    }
     if (options) helperOptions.set(name, options);
 };
 
@@ -133,28 +136,13 @@ export const resolvePath = (path, context) => {
     // Current context: .
     if (path === '.') return unwrapSignal(context);
 
-    // Global absolute path: $/something
-    // First check if the root is in the local context's state (cdom-state)
-    // This allows $/cart to resolve from cdom-state: { cart: {...} }
-    if (path.startsWith('$/')) {
+    // Global absolute path: =/something
+    if (path.startsWith('=/')) {
         const [rootName, ...rest] = path.slice(2).split('/');
-
-        // Check local state chain first (via __state__ property set by handleCDOMState)
-        let cur = context;
-        while (cur) {
-            const localState = cur.__state__;
-            if (localState && rootName in localState) {
-                return traverse(localState[rootName], rest);
-            }
-            cur = cur.__parent__;
-        }
-
-        // Then check global registry
-        const rootSignal = registry?.get(rootName);
-        if (!rootSignal) return undefined;
-
-        // Root can be a signal or a state proxy
-        return traverse(rootSignal, rest);
+        const LV = getLV();
+        const root = LV ? LV.get(rootName, { scope: context?.__node__ || context }) : registry?.get(rootName);
+        if (!root) return undefined;
+        return traverse(root, rest);
     }
 
     // Relative path from current context
@@ -196,27 +184,14 @@ export const resolvePathAsContext = (path, context) => {
     // Current context: .
     if (path === '.') return context;
 
-    // Global absolute path: $/something
-    // First check if the root is in the local context's state (cdom-state)
-    if (path.startsWith('$/')) {
+    // Global absolute path: =/something
+    if (path.startsWith('=/')) {
         const segments = path.slice(2).split(/[/.]/);
         const rootName = segments.shift();
-
-        // Check local state chain first
-        let cur = context;
-        while (cur) {
-            const localState = cur.__state__;
-            if (localState && rootName in localState) {
-                return traverseAsContext(localState[rootName], segments);
-            }
-            cur = cur.__parent__;
-        }
-
-        // Then check global registry
-        const rootSignal = registry?.get(rootName);
-        if (!rootSignal) return undefined;
-
-        return traverseAsContext(rootSignal, segments);
+        const LV = getLV();
+        const root = LV ? LV.get(rootName, { scope: context?.__node__ || context }) : registry?.get(rootName);
+        if (!root) return undefined;
+        return traverseAsContext(root, segments);
     }
 
     // Relative path from current context
@@ -260,6 +235,11 @@ class LazyValue {
     }
 }
 
+/**
+ * Node helper - identifies if a value is a DOM node.
+ */
+const isNode = (val) => val && typeof val === 'object' && globalThis.Node && val instanceof globalThis.Node;
+
 /**
  * Helper to resolve an argument which could be a literal, a path, or an explosion.
  * @param {string} arg - The argument string
@@ -294,10 +274,23 @@ const resolveArgument = (arg, context, globalMode = false) => {
         };
     }
 
-    // 5. Event Placeholder ($event)
+    // 5. Context Identifiers ($this, $event)
+    if (arg === '$this' || arg.startsWith('$this/') || arg.startsWith('$this.')) {
+        return {
+            value: new LazyValue((context) => {
+                const node = context?.__node__ || context;
+                if (arg === '$this') return node;
+                const path = arg.startsWith('$this.') ? arg.slice(6) : arg.slice(6);
+                return resolvePath(path, node);
+            }),
+            isLazy: true
+        };
+    }
+
     if (arg === '$event' || arg.startsWith('$event/') || arg.startsWith('$event.')) {
         return {
-            value: new LazyValue((event) => {
+            value: new LazyValue((context) => {
+                const event = context?.$event || context?.event || context;
                 if (arg === '$event') return event;
                 const path = arg.startsWith('$event.') ? arg.slice(7) : arg.slice(7);
                 return resolvePath(path, event);
@@ -311,14 +304,25 @@ const resolveArgument = (arg, context, globalMode = false) => {
         try {
             const data = parseJPRX(arg);
 
-            // Define a recursive resolver for template objects
             const resolveTemplate = (node, context) => {
                 if (typeof node === 'string') {
-                    if (node.startsWith('$')) {
+                    if (node.startsWith('=')) {
                         const res = resolveExpression(node, context);
                         const final = (res instanceof LazyValue) ? res.resolve(context) : res;
                         return unwrapSignal(final);
                     }
+                    if (node === '$this' || node.startsWith('$this/') || node.startsWith('$this.')) {
+                        const path = (node.startsWith('$this.') || node.startsWith('$this/')) ? node.slice(6) : node.slice(6);
+                        const ctxNode = context?.__node__ || context;
+                        const res = node === '$this' ? ctxNode : resolvePath(path, ctxNode);
+                        return unwrapSignal(res);
+                    }
+                    if (node === '$event' || node.startsWith('$event/') || node.startsWith('$event.')) {
+                        const path = (node.startsWith('$event.') || node.startsWith('$event/')) ? node.slice(7) : node.slice(7);
+                        const event = context?.$event || context?.event || (context && !isNode(context) ? context : null);
+                        const res = node === '$event' ? event : resolvePath(path, event);
+                        return unwrapSignal(res);
+                    }
                     if (node === '_' || node.startsWith('_/') || node.startsWith('_.')) {
                         const path = (node.startsWith('_.') || node.startsWith('_/')) ? node.slice(2) : node.slice(2);
                         const res = node === '_' ? context : resolvePath(path, context);
@@ -335,10 +339,9 @@ const resolveArgument = (arg, context, globalMode = false) => {
                 return node;
             };
 
-            // Check if it contains any reactive parts
             const hasReactive = (obj) => {
                 if (typeof obj === 'string') {
-                    return obj.startsWith('$') || obj.startsWith('_') || obj.startsWith('../');
+                    return obj.startsWith('=') || obj.startsWith('_') || obj.startsWith('../');
                 }
                 if (Array.isArray(obj)) return obj.some(hasReactive);
                 if (obj && typeof obj === 'object') return Object.values(obj).some(hasReactive);
@@ -361,9 +364,9 @@ const resolveArgument = (arg, context, globalMode = false) => {
     if (arg.includes('(')) {
         let nestedExpr = arg;
         if (arg.startsWith('/')) {
-            nestedExpr = '$' + arg;
-        } else if (globalMode && !arg.startsWith('$') && !arg.startsWith('./')) {
-            nestedExpr = `$/${arg}`;
+            nestedExpr = '=' + arg;
+        } else if (globalMode && !arg.startsWith('=') && !arg.startsWith('./')) {
+            nestedExpr = `=/${arg}`;
         }
 
         const val = resolveExpression(nestedExpr, context);
@@ -376,11 +379,11 @@ const resolveArgument = (arg, context, globalMode = false) => {
     // 8. Path normalization
     let normalizedPath;
     if (arg.startsWith('/')) {
-        normalizedPath = '$' + arg;
-    } else if (arg.startsWith('$') || arg.startsWith('./') || arg.startsWith('../')) {
+        normalizedPath = '=' + arg;
+    } else if (arg.startsWith('=') || arg.startsWith('./') || arg.startsWith('../')) {
         normalizedPath = arg;
     } else if (globalMode) {
-        normalizedPath = `$/${arg}`;
+        normalizedPath = `=/${arg}`;
     } else {
         normalizedPath = `./${arg}`;
     }
@@ -433,6 +436,7 @@ const TokenType = {
     COMMA: 'COMMA',         // ,
     EXPLOSION: 'EXPLOSION', // ... suffix
     PLACEHOLDER: 'PLACEHOLDER', // _, _/path
+    THIS: 'THIS',           // $this
     EVENT: 'EVENT',         // $event, $event.target
     EOF: 'EOF'
 };
@@ -477,20 +481,21 @@ const tokenize = (expr) => {
             continue;
         }
 
-        // Special: $ followed immediately by an operator symbol
-        // In expressions like "$++/count", the $ is just the JPRX delimiter
+        // Special: = followed immediately by an operator symbol
+        // 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) {
+        if (expr[i] === '=' && i + 1 < len) {
+            // 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;
             }
@@ -547,7 +552,7 @@ const tokenize = (expr) => {
                     tokens[tokens.length - 1].type === TokenType.LPAREN ||
                     tokens[tokens.length - 1].type === TokenType.COMMA ||
                     tokens[tokens.length - 1].type === TokenType.OPERATOR;
-                const validAfter = /[\s($./'"0-9_]/.test(after) ||
+                const validAfter = /[\s(=./'"0-9_]/.test(after) ||
                     i + op.length >= len ||
                     opSymbols.some(o => expr.slice(i + op.length).startsWith(o));
 
@@ -620,6 +625,18 @@ const tokenize = (expr) => {
             continue;
         }
 
+        // $this placeholder
+        if (expr.slice(i, i + 5) === '$this') {
+            let thisPath = '$this';
+            i += 5;
+            while (i < len && /[a-zA-Z0-9_./]/.test(expr[i])) {
+                thisPath += expr[i];
+                i++;
+            }
+            tokens.push({ type: TokenType.THIS, value: thisPath });
+            continue;
+        }
+
         // $event placeholder
         if (expr.slice(i, i + 6) === '$event') {
             let eventPath = '$event';
@@ -632,8 +649,8 @@ const tokenize = (expr) => {
             continue;
         }
 
-        // Paths: start with $, ., or /
-        if (expr[i] === '$' || expr[i] === '.' || expr[i] === '/') {
+        // Paths: start with =, ., or /
+        if (expr[i] === '=' || expr[i] === '.' || expr[i] === '/') {
             let path = '';
             // Consume the path, but stop at operators
             while (i < len) {
@@ -715,9 +732,9 @@ const tokenize = (expr) => {
  * Used to determine whether to use Pratt parser or legacy parser.
  * 
  * CONSERVATIVE: Only detect explicit patterns to avoid false positives.
- * - Prefix: $++/path, $--/path, $!!/path (operator immediately after $ before path)
- * - Postfix: $/path++ or $/path-- (operator at end of expression, not followed by ()
- * - Infix with spaces: $/path + $/other (spaces around operator)
+ * - Prefix: =++/path, =--/path, =!!/path (operator immediately after = before path)
+ * - Postfix: =/path++ or =/path-- (operator at end of expression, not followed by ()
+ * - Infix with spaces: =/path + =/other (spaces around operator)
  */
 const hasOperatorSyntax = (expr) => {
     if (!expr || typeof expr !== 'string') return false;
@@ -725,19 +742,19 @@ const hasOperatorSyntax = (expr) => {
     // Skip function calls - they use legacy parser
     if (expr.includes('(')) return false;
 
-    // Check for prefix operator pattern: $++ or $-- followed by /
-    // This catches: $++/counter, $--/value
-    if (/^\$(\+\+|--|!!)\/?/.test(expr)) {
+    // Check for prefix operator pattern: =++ or =-- followed by /
+    // This catches: =++/counter, =--/value
+    if (/^=(\+\+|--|!!)\/?/.test(expr)) {
         return true;
     }
 
     // Check for postfix operator pattern: path ending with ++ or --
-    // This catches: $/counter++, $/value--
+    // This catches: =/counter++, =/value--
     if (/(\+\+|--)$/.test(expr)) {
         return true;
     }
 
-    // Check for infix with explicit whitespace: $/a + $/b
+    // Check for infix with explicit whitespace: =/a + =/b
     // The spaces make it unambiguous that the symbol is an operator, not part of a path
     if (/\s+([+\-*/]|>|<|>=|<=|!=)\s+/.test(expr)) {
         return true;
@@ -796,7 +813,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 };
@@ -814,6 +831,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();
@@ -871,6 +894,12 @@ class PrattParser {
             return { type: 'Placeholder', value: tok.value };
         }
 
+        // This
+        if (tok.type === TokenType.THIS) {
+            this.consume();
+            return { type: 'This', value: tok.value };
+        }
+
         // Event
         if (tok.type === TokenType.EVENT) {
             this.consume();
@@ -927,8 +956,18 @@ const evaluateAST = (ast, context, forMutation = false) => {
             });
         }
 
+        case 'This': {
+            return new LazyValue((context) => {
+                const node = context?.__node__ || context;
+                if (ast.value === '$this') return node;
+                const path = ast.value.startsWith('$this.') ? ast.value.slice(6) : ast.value.slice(6);
+                return resolvePath(path, node);
+            });
+        }
+
         case 'Event': {
-            return new LazyValue((event) => {
+            return new LazyValue((context) => {
+                const event = context?.$event || context?.event || context;
                 if (ast.value === '$event') return event;
                 const path = ast.value.startsWith('$event.') ? ast.value.slice(7) : ast.value.slice(7);
                 return resolvePath(path, event);
@@ -985,7 +1024,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:
@@ -1032,19 +1082,19 @@ export const resolveExpression = (expr, context) => {
         const argsStr = expr.slice(funcStart + 1, -1);
 
         const segments = fullPath.split('/');
-        let funcName = segments.pop().replace(/^\$/, '');
+        let funcName = segments.pop().replace(/^=/, '');
 
-        // Handle case where path ends in / (like $/ for division helper)
+        // Handle case where path ends in / (like =/ for division helper)
         if (funcName === '' && (segments.length > 0 || fullPath === '/')) {
             funcName = '/';
         }
 
         const navPath = segments.join('/');
 
-        const isGlobalExpr = expr.startsWith('$/') || expr.startsWith('$');
+        const isGlobalExpr = expr.startsWith('=/') || expr.startsWith('=');
 
         let baseContext = context;
-        if (navPath && navPath !== '$') {
+        if (navPath && navPath !== '=') {
             baseContext = resolvePathAsContext(navPath, context);
         }
 
@@ -1082,7 +1132,7 @@ export const resolveExpression = (expr, context) => {
         let hasLazy = false;
         for (let i = 0; i < argsList.length; i++) {
             const arg = argsList[i];
-            const useGlobalMode = isGlobalExpr && (navPath === '$' || !navPath);
+            const useGlobalMode = isGlobalExpr && (navPath === '=' || !navPath);
             const res = resolveArgument(arg, baseContext, useGlobalMode);
 
             if (res.isLazy) hasLazy = true;
@@ -1117,7 +1167,7 @@ export const resolveExpression = (expr, context) => {
             });
         }
 
-        const result = helper(...resolvedArgs);
+        const result = helper.apply(context?.__node__ || null, resolvedArgs);
         return unwrapSignal(result);
     }
 
@@ -1247,8 +1297,8 @@ export const parseCDOMC = (input) => {
 
         const word = input.slice(start, i);
 
-        // If word starts with $, preserve it as a string for cDOM expression parsing
-        if (word.startsWith('$')) {
+        // If word starts with =, preserve it as a string for cDOM expression parsing
+        if (word.startsWith('=')) {
             return word;
         }
 
@@ -1424,8 +1474,8 @@ export const parseJPRX = (input) => {
             continue;
         }
 
-        // Handle JPRX expressions starting with $ (MUST come before word handler!)
-        if (char === '$') {
+        // Handle JPRX expressions starting with = (MUST come before word handler!)
+        if (char === '=') {
             let expr = '';
             let parenDepth = 0;
             let braceDepth = 0;
@@ -1463,7 +1513,7 @@ export const parseJPRX = (input) => {
         }
 
         // Handle unquoted property names, identifiers, and paths
-        if (/[a-zA-Z_./]/.test(char)) {
+        if (/[a-zA-Z_$/./]/.test(char)) {
             let word = '';
             while (i < len && /[a-zA-Z0-9_$/.-]/.test(input[i])) {
                 word += input[i];

package/jprx/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/jprx/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"
+    }
+]