jprx 1.2.0 → 1.2.1

package/README.md

@@ -1,4 +1,4 @@
-# JPRX (JSON Reactive Path eXpressions)
+# JPRX (JSON Path Reactive eXpressions)
 
 **JPRX** is a declarative, reactive expression syntax designed for JSON-based data structures. It extends [JSON Pointer (RFC 6901)](https://www.rfc-editor.org/rfc/rfc6901) with reactivity, relative paths, operator syntax, and a rich library of helper functions.
 

package/helpers/calc.js

@@ -0,0 +1,82 @@
+/**
+ * JPRX CALC HELPER
+ * Safe expression evaluation using expr-eval.
+ * Uses the global $ helper for reactive path lookups.
+ */
+
+import { Parser } from 'expr-eval';
+import { resolvePath, unwrapSignal } from '../parser.js';
+
+/**
+ * Evaluates a mathematical expression string.
+ * Supports $() for reactive path lookups within the expression.
+ * 
+ * @param {string} expression - The expression to evaluate (e.g., "$('/price') * 1.08")
+ * @param {object} context - The JPRX context for path resolution
+ * @returns {number|string} - The result of the evaluation
+ * 
+ * @example
+ * =calc("$('/width') * $('/height')")
+ * =calc("5 + 3 * 2")
+ * =calc("($('/subtotal') + $('/tax')) * 0.9")
+ */
+export const calc = (expression, context) => {
+    if (typeof expression !== 'string') {
+        return expression;
+    }
+
+    let processedExpression = expression;
+    try {
+        const pathResolver = (path) => {
+            let currentPath = path;
+            let value;
+            let depth = 0;
+
+            // Recursively resolve if the value is another path string (e.g., "/c/display")
+            while (typeof currentPath === 'string' && (currentPath.startsWith('/') || currentPath.startsWith('=/')) && depth < 5) {
+                const normalizedPath = currentPath.startsWith('/') ? '=' + currentPath : currentPath;
+                const resolved = resolvePath(normalizedPath, context);
+                value = unwrapSignal(resolved);
+
+                // If the new value is a different path string, keep going
+                if (typeof value === 'string' && (value.startsWith('/') || value.startsWith('=/')) && value !== currentPath) {
+                    currentPath = value;
+                    depth++;
+                } else {
+                    break;
+                }
+            }
+
+            if (typeof value === 'number') return value;
+            if (typeof value === 'string') {
+                const num = parseFloat(value);
+                if (!isNaN(num) && isFinite(Number(value))) return num;
+                return value === '' ? 0 : `"${value.replace(/"/g, '\\"')}"`;
+            }
+            return value === undefined || value === null ? 0 : value;
+        };
+
+        const pathRegex = /\$\(\s*['"](.*?)['"]\s*\)/g;
+        processedExpression = expression.replace(pathRegex, (match, path) => {
+            const val = pathResolver(path);
+            return val;
+        });
+
+        const parser = new Parser();
+        const parsed = parser.parse(processedExpression);
+        return parsed.evaluate();
+
+    } catch (error) {
+        console.error('JPRX calc error:', error.message);
+        console.error('Original expression:', expression);
+        console.error('Processed expression:', processedExpression);
+        return NaN;
+    }
+};
+
+/**
+ * Register the calc helper.
+ */
+export const registerCalcHelpers = (register) => {
+    register('calc', calc, { pathAware: true });
+};

package/helpers/lookup.js

@@ -2,6 +2,8 @@
  * cdom LOOKUP HELPERS
  */
 
+import { resolvePath, unwrapSignal } from '../parser.js';
+
 export const lookup = (val, searchArr, resultArr) => {
     if (!Array.isArray(searchArr)) return undefined;
     const idx = searchArr.indexOf(val);
@@ -17,9 +19,46 @@ export const vlookup = (val, table, colIdx) => {
 export const index = (arr, idx) => Array.isArray(arr) ? arr[idx] : undefined;
 export const match = (val, arr) => Array.isArray(arr) ? arr.indexOf(val) : -1;
 
+/**
+ * $ - Reactive path lookup helper.
+ * Resolves a JPRX path string and returns the unwrapped value.
+ * 
+ * @param {string} path - The path to resolve (e.g., '/state/count')
+ * @param {object} context - The JPRX context (automatically provided by pathAware)
+ * @returns {any} - The resolved and unwrapped value
+ * 
+ * @example
+ * =calc("$('/price') * 1.08")
+ * =$('/user/name')
+ */
+export const pathRef = (path, context) => {
+    // If path is already a BindingTarget or has a .value property, use it directly
+    if (path && typeof path === 'object' && 'value' in path) {
+        return unwrapSignal(path.value);
+    }
+
+    // Fallback for string paths
+    if (typeof path === 'string') {
+        const normalized = path.startsWith('=') ? path : '=' + path;
+        const resolved = resolvePath(normalized, context);
+        const value = unwrapSignal(resolved);
+        // Convert to number if it looks like a number for calc compatibility
+        if (typeof value === 'number') return value;
+        if (typeof value === 'string' && value !== '' && !isNaN(parseFloat(value)) && isFinite(Number(value))) {
+            return parseFloat(value);
+        }
+        return value;
+    }
+
+    return unwrapSignal(path);
+};
+
 export const registerLookupHelpers = (register) => {
     register('lookup', lookup);
     register('vlookup', vlookup);
     register('index', index);
     register('match', match);
+    register('$', pathRef, { pathAware: true });
+    register('val', pathRef, { pathAware: true });
+    register('indirect', pathRef, { pathAware: true });
 };

package/helpers/math.js

@@ -14,6 +14,8 @@ export const abs = (val) => Math.abs(val);
 export const mod = (a, b) => a % b;
 export const pow = (a, b) => Math.pow(a, b);
 export const sqrt = (val) => Math.sqrt(val);
+export const negate = (val) => -Number(val);
+export const toPercent = (val) => Number(val) / 100;
 
 export const registerMathHelpers = (register) => {
     register('+', add);
@@ -31,4 +33,6 @@ export const registerMathHelpers = (register) => {
     register('mod', mod);
     register('pow', pow);
     register('sqrt', sqrt);
+    register('negate', negate);
+    register('toPercent', toPercent);
 };

package/index.js

@@ -38,6 +38,7 @@ export { registerLookupHelpers } from './helpers/lookup.js';
 export { registerStatsHelpers } from './helpers/stats.js';
 export { registerStateHelpers, set } from './helpers/state.js';
 export { registerNetworkHelpers } from './helpers/network.js';
+export { registerCalcHelpers, calc } from './helpers/calc.js';
 
 // Convenience function to register all standard helpers
 export const registerAllHelpers = (registerFn) => {
@@ -53,6 +54,7 @@ export const registerAllHelpers = (registerFn) => {
     const { registerStatsHelpers } = require('./helpers/stats.js');
     const { registerStateHelpers } = require('./helpers/state.js');
     const { registerNetworkHelpers } = require('./helpers/network.js');
+    const { registerCalcHelpers } = require('./helpers/calc.js');
 
     registerMathHelpers(registerFn);
     registerLogicHelpers(registerFn);
@@ -66,4 +68,5 @@ export const registerAllHelpers = (registerFn) => {
     registerStatsHelpers(registerFn);
     registerStateHelpers((name, fn) => registerFn(name, fn, { pathAware: true }));
     registerNetworkHelpers(registerFn);
+    registerCalcHelpers(registerFn);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "jprx",
-    "version": "1.2.0",
-    "description": "JSON Reactive Path eXpressions - A reactive expression language for JSON data",
+    "version": "1.2.1",
+    "description": "JSON Path Reactive eXpressions - A reactive expression language for JSON data",
     "main": "index.js",
     "type": "module",
     "keywords": [

package/parser.js

@@ -164,7 +164,6 @@ export const resolvePath = (path, context) => {
     const unwrappedContext = unwrapSignal(context);
     if (unwrappedContext && typeof unwrappedContext === 'object') {
         if (path in unwrappedContext || unwrappedContext[path] !== undefined) {
-            // Use traverse with one segment to ensure signal unwrapping if context[path] is a signal
             return traverse(unwrappedContext, [path]);
         }
     }
@@ -1512,7 +1511,7 @@ export const parseJPRX = (input) => {
             continue;
         }
 
-        // Handle unquoted property names, identifiers, and paths
+        // Handle unquoted property names, identifiers, paths, and FUNCTION CALLS
         if (/[a-zA-Z_$/./]/.test(char)) {
             let word = '';
             while (i < len && /[a-zA-Z0-9_$/.-]/.test(input[i])) {
@@ -1520,13 +1519,46 @@ export const parseJPRX = (input) => {
                 i++;
             }
 
-            // Skip whitespace to check for :
+            // Skip whitespace to check what follows
             let j = i;
             while (j < len && /\s/.test(input[j])) j++;
 
             if (input[j] === ':') {
                 // It's a property name - quote it
                 result += `"${word}"`;
+            } else if (input[j] === '(') {
+                // It's a FUNCTION CALL - capture the entire expression with balanced parens
+                let expr = word;
+                i = j; // move to the opening paren
+                let parenDepth = 0;
+                let inQuote = null;
+
+                while (i < len) {
+                    const c = input[i];
+
+                    // Track quotes to avoid false paren matches inside strings
+                    if (inQuote) {
+                        if (c === inQuote && input[i - 1] !== '\\') inQuote = null;
+                    } else if (c === '"' || c === "'") {
+                        inQuote = c;
+                    } else {
+                        if (c === '(') parenDepth++;
+                        else if (c === ')') {
+                            parenDepth--;
+                            if (parenDepth === 0) {
+                                expr += c;
+                                i++;
+                                break;
+                            }
+                        }
+                    }
+
+                    expr += c;
+                    i++;
+                }
+
+                // Treat the function call as a JPRX expression by prefixing with =
+                result += JSON.stringify('=' + expr);
             } else {
                 // It's a value - check if it's a keyword
                 if (word === 'true' || word === 'false' || word === 'null') {