pgo-ui 1.1.13 → 1.1.16

package/src/pgo-components/lib/componentConfig.js

@@ -270,20 +270,104 @@ export function createSafeFunction(params, body, context) {
 }
 
 // Example: initializeFunctions utility
-export function initializeFunctions(functionsObj, context) {
-  const compiledFunctions = {};
-  if (functionsObj) {
-    Object.keys(functionsObj).forEach(funcName => {
-      const funcString = functionsObj[funcName];
-      try {
-        compiledFunctions[funcName] = createSafeFunction(['response'], funcString, context);
-      } catch (error) {
-        console.error(`Error compiling function ${funcName}:`, error);
-        compiledFunctions[funcName] = (response) => {
-          console.warn(`Function ${funcName} failed to compile, received:`, response);
-        };
-      }
-    });
-  }
-  return compiledFunctions;
+// export function initializeFunctions(functionsObj, context) {
+//   const compiledFunctions = {};
+//   if (functionsObj) {
+//     Object.keys(functionsObj).forEach(funcName => {
+//       const funcString = functionsObj[funcName];
+//       try {
+//         compiledFunctions[funcName] = createSafeFunction(['response'], funcString, context);
+//       } catch (error) {
+//         console.error(`Error compiling function ${funcName}:`, error);
+//         compiledFunctions[funcName] = (response) => {
+//           console.warn(`Function ${funcName} failed to compile, received:`, response);
+//         };
+//       }
+//     });
+//   }
+//   return compiledFunctions;
+// }
+
+// Reusable safe eval helper
+const safeEval = (expression, context) => {
+    const functionKeys = []
+    const functionValues = []
+    const varDeclarations = []
+
+    Object.keys(context)
+        .filter(key => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key))
+        .forEach(key => {
+            const value = context[key]
+
+            if (typeof value === 'function') {
+                // Pass functions as parameters
+                functionKeys.push(key)
+                functionValues.push(value)
+            } else if (typeof value === 'object' && value !== null) {
+                // Pass ALL objects as parameters (preserves reactivity, avoids JSON issues)
+                functionKeys.push(key)
+                functionValues.push(value)
+            } else if (value === null || value === undefined) {
+                varDeclarations.push(`var ${key} = null;`)
+            } else if (typeof value === 'string') {
+                varDeclarations.push(`var ${key} = ${JSON.stringify(value)};`)
+            } else if (typeof value === 'boolean') {
+                varDeclarations.push(`var ${key} = ${value};`)
+            } else if (typeof value === 'number') {
+                varDeclarations.push(`var ${key} = ${value};`)
+            } else {
+                varDeclarations.push(`var ${key} = null;`)
+            }
+        })
+
+    // expression is used as-is — caller decides whether to add "return (...)"
+    const body = varDeclarations.join('\n') + `\n${expression}`
+    const fn = new Function(...functionKeys, body)
+    return fn(...functionValues)
+}
+
+const initializeFunctions = (functions, baseContext = {}) => {
+    const compiled = {}
+
+    if (!functions || typeof functions !== 'object') {
+        return compiled
+    }
+
+    Object.entries(functions).forEach(([name, functionBody]) => {
+        if (typeof functionBody !== 'string') return
+
+        try {
+            compiled[name] = (...args) => {
+                // Create a fresh context merging base with call-time args
+                const context = { ...baseContext }
+
+                // Add common function-specific arguments
+                if (args[0] !== undefined) context.response = args[0]
+                if (args[1] !== undefined) context.item = args[1]
+                if (args[2] !== undefined) context.event = args[2]
+
+                // Add positional args
+                args.forEach((arg, index) => {
+                    context[`arg${index}`] = arg
+                })
+
+                try {
+                    return safeEval(functionBody, context)
+                } catch (error) {
+                    console.warn(`Error executing function "${name}":`, error.message)
+                    console.warn('Function body was:', functionBody)
+                    return null
+                }
+            }
+        } catch (error) {
+            console.warn(`Error compiling function "${name}":`, error.message)
+        }
+    })
+
+    return compiled
+}
+
+export {
+    safeEval,
+    initializeFunctions,
 }