Make isUndefined(x) lazy so it can guard against unbound variables (0.6.3)

Calling `isUndefined(some_nonexistent_variable)` used to throw
VariableError because evalCall eagerly evaluates each argument. That
defeats the function's whole purpose: you can't write
`isUndefined(x) ? "fallback" : x` to defend against missing inputs.

Special-case isUndefined in both evaluators (mirroring the existing
lazy `if()` pattern): catch VariableError raised while evaluating the
single argument and treat the value as `undefined`. Gated on
`!expr.legacy` for consistency with `if()`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Sander Toonen

packages/expreszo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pro-fa/expreszo",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Mathematical expression evaluator",
   "keywords": [
     "expression",

packages/expreszo/src/eval/async-evaluator.ts

@@ -283,6 +283,24 @@ async function evalCall(
       : evalNode(node.args[2], expr, values, resolver);
   }
 
+  // Lazy isUndefined(x): an unbound `x` is treated as undefined, not an error,
+  // so the function can be used as a guard (`isUndefined(x) ? fallback : x`).
+  if (
+    !expr.legacy &&
+    node.callee.type === 'Ident' &&
+    node.callee.name === 'isUndefined' &&
+    node.args.length === 1
+  ) {
+    let argValue: Value;
+    try {
+      argValue = await evalNode(node.args[0], expr, values, resolver);
+    } catch (err) {
+      if (!(err instanceof VariableError)) throw err;
+      argValue = undefined;
+    }
+    return argValue === undefined;
+  }
+
   const callee = await evalNode(node.callee, expr, values, resolver);
   const args = await Promise.all(
     node.args.map((arg) => evalNode(arg, expr, values, resolver))

packages/expreszo/src/eval/sync-evaluator.ts

@@ -287,6 +287,24 @@ function evalCall(
       : evalNode(node.args[2], expr, values, resolver);
   }
 
+  // Lazy isUndefined(x): an unbound `x` is treated as undefined, not an error,
+  // so the function can be used as a guard (`isUndefined(x) ? fallback : x`).
+  if (
+    !expr.legacy &&
+    node.callee.type === 'Ident' &&
+    node.callee.name === 'isUndefined' &&
+    node.args.length === 1
+  ) {
+    let argValue: Value;
+    try {
+      argValue = evalNode(node.args[0], expr, values, resolver);
+    } catch (err) {
+      if (!(err instanceof VariableError)) throw err;
+      argValue = undefined;
+    }
+    return argValue === undefined;
+  }
+
   const callee = evalNode(node.callee, expr, values, resolver);
   const args: Value[] = new Array(node.args.length);
   for (let i = 0; i < node.args.length; i++) {

packages/expreszo/test/functions/functions-type-checking.ts

@@ -132,6 +132,28 @@ describe('Type Checking Functions TypeScript Test', function () {
       assert.strictEqual(parser.evaluate('isUndefined({})'), false);
       assert.strictEqual(parser.evaluate('isUndefined(null)'), false);
     });
+    it('should return true for variables that are not bound at all', function () {
+      const parser = new Parser();
+      assert.strictEqual(parser.evaluate('isUndefined(some_nonexistent_variable)'), true);
+    });
+    it('should return true for member access on a missing root variable', function () {
+      const parser = new Parser();
+      assert.strictEqual(parser.evaluate('isUndefined(missing.nested.path)'), true);
+    });
+    it('should be usable in a ternary as a guard against missing variables', function () {
+      const parser = new Parser();
+      assert.strictEqual(
+        parser.evaluate('isUndefined(missing) ? "fallback" : missing'),
+        'fallback'
+      );
+    });
+    it('should still return false for bound variables when used in a ternary guard', function () {
+      const parser = new Parser();
+      assert.strictEqual(
+        parser.evaluate('isUndefined(x) ? "fallback" : x', { x: 'hello' }),
+        'hello'
+      );
+    });
   });
 
   describe('isFunction(value)', function () {