Fix ?? so non-numeric strings no longer trigger the fallback (0.6.2)

The old coalesce used global `isNaN(a)`, which coerces its argument to a
number first — so `"hello" ?? "fallback"` (and any non-empty array or
plain object) wrongly fell through to the fallback. Switch to
`Number.isNaN`, guard the numeric branch with `typeof a === 'number'`,
and treat empty string / array / object as missing values too. Also
covers `-Infinity` for symmetry with `Infinity`.

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

Author: Sander Toonen

docs/syntax.md

@@ -560,11 +560,15 @@ x == undefined      → true (if x is not defined)
 
 ## Coalesce Operator
 
-The `??` operator returns the right operand when the left operand is null, undefined, Infinity, or NaN:
+The `??` operator returns the right operand when the left operand is "missing" — that is,
+`null`, `undefined`, an empty string `""`, an empty array `[]`, an empty object `{}`,
+`Infinity` (positive or negative), or `NaN`:
 
 ```
 x ?? 0                    → 0 (if x is undefined or null)
 y ?? "default"            → y (if y has a value)
+"" ?? "default"           → "default"
+[] ?? "default"           → "default"
 10 / 0 ?? -1              → -1 (division by zero gives Infinity)
 sqrt(-1) ?? 0             → 0 (sqrt of negative gives NaN)
 ```

packages/expreszo/package.json

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

packages/expreszo/src/operators/binary/utility.ts

@@ -4,6 +4,7 @@
  */
 
 import { AccessError } from '../../types/errors.js';
+import { isValueArray, isValueObject } from '../../types/type-guards.js';
 import { DANGEROUS_PROPERTIES } from '../../validation/constants.js';
 
 export function concat(a: any, b: any): any[] | string | undefined {
@@ -68,7 +69,12 @@ export function arrayIndexOrProperty(parent: any, index: number | string | undef
 }
 
 export function coalesce(a: any, b: any): any {
-  return a === undefined || a === null || a === Infinity || isNaN(a) ? b : a;
+  if (a === undefined || a === null) return b;
+  if (a === '') return b;
+  if (typeof a === 'number' && (a === Infinity || a === -Infinity || Number.isNaN(a))) return b;
+  if (isValueArray(a) && a.length === 0) return b;
+  if (isValueObject(a) && Object.keys(a).length === 0) return b;
+  return a;
 }
 
 export function asOperator(a: any, b: string | undefined): any {

packages/expreszo/test/expression/expression-advanced.ts

@@ -400,6 +400,24 @@ describe('Expression Advanced Features TypeScript Test', () => {
       expect(parser.evaluate('NaN ?? 0')).toBe(0);
     });
 
+    it('returns the value for non-empty strings (regression: was returning fallback)', () => {
+      expect(parser.evaluate('s ?? "fallback"', { s: 'hello' })).toBe('hello');
+    });
+
+    it('returns the fallback for empty strings', () => {
+      expect(parser.evaluate('s ?? "fallback"', { s: '' })).toBe('fallback');
+    });
+
+    it('returns the fallback for empty arrays and objects', () => {
+      expect(parser.evaluate('a ?? "fallback"', { a: [] })).toBe('fallback');
+      expect(parser.evaluate('o ?? "fallback"', { o: {} })).toBe('fallback');
+    });
+
+    it('passes through non-empty arrays and objects', () => {
+      expect(parser.evaluate('a ?? "fallback"', { a: [1, 2] })).toEqual([1, 2]);
+      expect(parser.evaluate('o ?? "fallback"', { o: { x: 1 } })).toEqual({ x: 1 });
+    });
+
     it('should be disabled by the coalesce option', () => {
       const parser = new Parser({ operators: { coalesce: false } });
       expect(() => parser.evaluate('1 ?? 2')).toThrow(/Unknown character/);

packages/expreszo/test/operators/binary/utility.ts

@@ -308,28 +308,39 @@ describe('Binary Utility Operators', () => {
       expect(coalesce(Infinity, 'fallback')).toBe('fallback');
     });
 
+    it('should return fallback when first value is -Infinity', () => {
+      expect(coalesce(-Infinity, 'fallback')).toBe('fallback');
+    });
+
     it('should return fallback when first value is NaN', () => {
       expect(coalesce(NaN, 'fallback')).toBe('fallback');
     });
 
-    it('should return 0 when first value is 0', () => {
-      expect(coalesce(0, 'fallback')).toBe(0);
+    it('should return fallback when first value is empty string', () => {
+      expect(coalesce('', 'fallback')).toBe('fallback');
+    });
+
+    it('should return fallback when first value is empty array', () => {
+      expect(coalesce([], 'fallback')).toBe('fallback');
     });
 
-    it('should return empty string when first value is empty string', () => {
-      expect(coalesce('', 'fallback')).toBe('');
+    it('should return fallback when first value is empty object', () => {
+      expect(coalesce({}, 'fallback')).toBe('fallback');
+    });
+
+    it('should return 0 when first value is 0', () => {
+      expect(coalesce(0, 'fallback')).toBe(0);
     });
 
     it('should return false when first value is false', () => {
       expect(coalesce(false, 'fallback')).toBe(false);
     });
 
-    it('should return fallback for non-numeric strings (isNaN coerces to NaN)', () => {
-      expect(coalesce('hello', 'fallback')).toBe('fallback');
+    it('should return non-numeric strings unchanged', () => {
+      expect(coalesce('hello', 'fallback')).toBe('hello');
     });
 
     it('should return numeric string when it is valid', () => {
-      // isNaN('42') is false because '42' coerces to 42
       expect(coalesce('42', 'fallback')).toBe('42');
     });
 
@@ -338,17 +349,12 @@ describe('Binary Utility Operators', () => {
       expect(coalesce(-1, 0)).toBe(-1);
     });
 
-    it('should return fallback for arrays (isNaN coerces array to NaN)', () => {
-      expect(coalesce([1, 2], 'fallback')).toBe('fallback');
-    });
-
-    it('should return fallback for objects (isNaN coerces object to NaN)', () => {
-      expect(coalesce({ a: 1 }, 'fallback')).toBe('fallback');
+    it('should return non-empty arrays unchanged', () => {
+      expect(coalesce([1, 2], 'fallback')).toEqual([1, 2]);
     });
 
-    it('should return -Infinity (not caught by === Infinity or isNaN)', () => {
-      // -Infinity !== Infinity, and isNaN(-Infinity) is false
-      expect(coalesce(-Infinity, 'fallback')).toBe(-Infinity);
+    it('should return non-empty objects unchanged', () => {
+      expect(coalesce({ a: 1 }, 'fallback')).toEqual({ a: 1 });
     });
   });