Improve CSP build

.github/workflows/run-tests.yml

@@ -11,3 +11,4 @@ jobs:
       - run: npm install
       - run: npm run build
       - run: npm run test
+      - run: npm run vitest

package.json

@@ -12,14 +12,15 @@
         "dot-json": "^1.2.2",
         "esbuild": "~0.16.17",
         "jest": "^26.6.3",
-        "sortablejs": "^1.15.2"
+        "sortablejs": "^1.15.2",
+        "vitest": "^3.2.4"
     },
     "scripts": {
         "build": "node ./scripts/build.js",
         "watch": "node ./scripts/build.js --watch",
         "test": "cypress run --quiet",
         "cypress": "cypress open",
-        "jest": "jest test",
+        "vitest": "vitest run",
         "update-docs": "node ./scripts/update-docs.js",
         "release": "node ./scripts/release.js"
     }

packages/alpinejs/src/evaluator.js

@@ -2,7 +2,7 @@ import { closestDataStack, mergeProxies } from './scope'
 import { injectMagics } from './magics'
 import { tryCatch, handleError } from './utils/error'
 
-let shouldAutoEvaluateFunctions = true
+export let shouldAutoEvaluateFunctions = true
 
 export function dontAutoEvaluateFunctions(callback) {
     let cache = shouldAutoEvaluateFunctions

packages/csp/src/evaluator.js

@@ -1,6 +1,7 @@
-import { generateEvaluatorFromFunction, runIfTypeOfFunction } from 'alpinejs/src/evaluator'
+import { generateEvaluatorFromFunction, shouldAutoEvaluateFunctions } from 'alpinejs/src/evaluator'
 import { closestDataStack, mergeProxies } from 'alpinejs/src/scope'
 import { tryCatch } from 'alpinejs/src/utils/error'
+import { generateRuntimeFunction } from './parser'
 import { injectMagics } from 'alpinejs/src/magics'
 
 export function cspEvaluator(el, expression) {
@@ -28,30 +29,22 @@ function generateEvaluator(el, expression, dataStack) {
     return (receiver = () => {}, { scope = {}, params = [] } = {}) => {
         let completeScope = mergeProxies([scope, ...dataStack])
 
-        let evaluatedExpression = expression.split('.').reduce(
-            (currentScope, currentExpression) => {
-                if (currentScope[currentExpression] === undefined) {
-                    throwExpressionError(el, expression)
-                }
+        let evaluate = generateRuntimeFunction(expression)
 
-                return currentScope[currentExpression]
-            },
-            completeScope,
-        );
+        let returnValue = evaluate(completeScope)
 
-        runIfTypeOfFunction(receiver, evaluatedExpression, completeScope, params)
-    }
-}
-
-function throwExpressionError(el, expression) {
-    console.warn(
-`Alpine Error: Alpine is unable to interpret the following expression using the CSP-friendly build:
+        if (shouldAutoEvaluateFunctions && typeof returnValue === 'function') {
+            let nextReturnValue = returnValue.apply(returnValue, params)
 
-"${expression}"
-
-Read more about the Alpine's CSP-friendly build restrictions here: https://alpinejs.dev/advanced/csp
-
-`,
-el
-    )
+            if (nextReturnValue instanceof Promise) {
+                nextReturnValue.then(i =>  receiver(i))
+            } else {
+                receiver(nextReturnValue)
+            }
+        } else if (typeof returnValue === 'object' && returnValue instanceof Promise) {
+            returnValue.then(i => receiver(i))
+        } else {
+            receiver(returnValue)
+        }
+    }
 }