@barefootjs/perl 0.17.0 → 0.17.1

package/lib/BarefootJS/DevReload.pm

@@ -1,5 +1,5 @@
 package BarefootJS::DevReload;
-our $VERSION = "0.16.0";
+our $VERSION = "0.17.0";
 use strict;
 use warnings;
 use feature 'signatures';

package/lib/BarefootJS/Evaluator.pm

@@ -108,8 +108,32 @@ sub evaluate ($node, $env) {
         }
         return \%out;
     }
+    if ($kind eq 'array-method' && ($node->{method} // '') eq 'includes'
+        && @{ $node->{args} // [] } == 1)
+    {
+        # `.includes(x)` (#2075) — the one `array-method` in the evaluator
+        # subset, shared between `Array.prototype.includes` (SameValueZero
+        # membership) and `String.prototype.includes` (substring search),
+        # matching the receiver-type dispatch the SSR template lowering does
+        # at runtime (`bf_includes` / `$bf->includes`). Mirrors the JS
+        # reference's `includes()` (eval-reference.ts).
+        my $obj    = evaluate($node->{object}, $env);
+        my $needle = evaluate($node->{args}[0], $env);
+        if (ref $obj eq 'ARRAY') {
+            for my $el (@$obj) {
+                return _bool(1) if _same_value_zero($el, $needle);
+            }
+            return _bool(0);
+        }
+        if (_is_string($obj)) {
+            return _bool(index($obj, _to_string($needle)) != -1);
+        }
+        # Any other receiver is not a JS `.includes` target — degrade to
+        # false rather than throwing, mirroring the reference.
+        return _bool(0);
+    }
 
-    # arrow-fn / higher-order / array-method / unsupported: a callback body
+    # arrow-fn / higher-order / unsupported array-method: a callback body
     # containing these is refused upstream (BF101); never reached here.
     return undef;
 }
@@ -276,6 +300,19 @@ sub _strict_eq ($l, $r) {
     return 0;
 }
 
+# _same_value_zero: `Array.prototype.includes` membership test — `===`
+# except `NaN` equals itself (and +0/-0 are not distinguished, which the
+# JSON-decoded values here can't represent anyway). Reuses `_strict_eq`'s
+# type/value rules and only special-cases the two-NaN case that `_strict_eq`
+# (deliberately, for `===`) reports as unequal.
+sub _same_value_zero ($l, $r) {
+    if (_is_number($l) && _is_number($r)) {
+        my ($lf, $rf) = ($l + 0, $r + 0);
+        return 1 if $lf != $lf && $rf != $rf;    # NaN sameValueZero NaN
+    }
+    return _strict_eq($l, $r);
+}
+
 sub _unary ($op, $v) {
     return _bool(!_truthy($v)) if $op eq '!';
     return -_to_number($v) if $op eq '-';
@@ -539,6 +576,21 @@ sub flat_map ($items, $proj, $param, $base_env = undef) {
     return \@out;
 }
 
+# map_items — project each element through $proj (a pure ParsedExpr), keeping
+# each result as one element (no flatten): JS value-producing `.map(cb)`
+# (#2073). Named map_items (not `map`) so the Perl builtin stays unshadowed.
+# Mirrors Go's MapEval. $base_env is optional.
+sub map_items ($items, $proj, $param, $base_env = undef) {
+    my @arr = ref $items eq 'ARRAY' ? @$items : ();
+    my %env = $base_env ? %$base_env : ();
+    my @out;
+    for my $item (@arr) {
+        $env{$param} = $item;
+        push @out, evaluate($proj, \%env);
+    }
+    return \@out;
+}
+
 # ---------------------------------------------------------------------------
 # JSON-string seams — the adapters emit `bf->filter_eval($recv, '<json>', …)`;
 # the predicate body arrives as a JSON string here, decoded then handed to the
@@ -575,4 +627,9 @@ sub flat_map_json ($items, $proj_json, $param, $base_env = undef) {
     return flat_map($items, JSON::PP->new->decode($proj_json), $param, $base_env);
 }
 
+sub map_json ($items, $proj_json, $param, $base_env = undef) {
+    require JSON::PP;
+    return map_items($items, JSON::PP->new->decode($proj_json), $param, $base_env);
+}
+
 1;

package/lib/BarefootJS.pm

@@ -1,5 +1,5 @@
 package BarefootJS;
-our $VERSION = "0.16.0";
+our $VERSION = "0.17.0";
 use strict;
 use warnings;
 use utf8;
@@ -581,8 +581,14 @@ sub round ($self, $value) {
 # receiver shapes apart without TS type inference, so both lower to
 # the same IR node (`array-method` / method `includes`). This helper
 # dispatches at the Perl level via `ref()`:
-#   - ARRAY ref:  scan elements with `eq`; one defined-vs-undef
-#                 hop matches JS's `===` for null/undefined.
+#   - ARRAY ref:  scan elements with `BarefootJS::Evaluator::_same_value_zero`,
+#                 matching `Array.prototype.includes`'s SameValueZero
+#                 semantics (no cross-type coercion, e.g. `[2].includes("2")`
+#                 is false; NaN matches NaN) — the same algorithm the
+#                 evaluator's serialized-callback path already uses for
+#                 `.includes`, so both positions agree. This used to be a
+#                 stringy `eq` scan, which coerced numbers to strings
+#                 (`[2].includes("2")` was true) and diverged from JS.
 #   - scalar:     `index($recv, $sub) != -1`, with both args
 #                 coerced through `// ''` so an undef receiver /
 #                 needle doesn't trip Perl's substr warning.
@@ -593,11 +599,7 @@ sub round ($self, $value) {
 sub includes ($self, $recv, $elem) {
     if (ref($recv) eq 'ARRAY') {
         for my $item (@$recv) {
-            if (!defined $item) {
-                return 1 if !defined $elem;
-                next;
-            }
-            return 1 if defined $elem && $item eq $elem;
+            return 1 if BarefootJS::Evaluator::_same_value_zero($item, $elem);
         }
         return 0;
     }
@@ -1180,6 +1182,13 @@ sub flat_map_eval ($self, $recv, $proj_json, $param, $base_env = {}) {
     return BarefootJS::Evaluator::flat_map_json($recv, $proj_json, $param, $base_env);
 }
 
+# Value-producing `.map(cb)` (#2073): project each element through the
+# serialized projection body, one result per element (no flatten). Composes
+# through the array-method chain (`.map(cb).join(' ')`).
+sub map_eval ($self, $recv, $proj_json, $param, $base_env = {}) {
+    return BarefootJS::Evaluator::map_json($recv, $proj_json, $param, $base_env);
+}
+
 sub sort ($self, $recv, $opts = {}) {
     return [] unless ref($recv) eq 'ARRAY';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/perl",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "BarefootJS engine-agnostic Perl runtime (BarefootJS.pm) — pluggable rendering backend; the shared basis for Mojolicious and other Perl framework integrations",
   "type": "module",
   "files": [

package/t/evaluator.t

@@ -20,6 +20,11 @@ sub ncall_math {
     return { kind => 'call', callee => nmem(nid('Math'), $fn), args => [$arg] };
 }
 
+sub nincludes {
+    my ($object, $needle) = @_;
+    return { kind => 'array-method', method => 'includes', object => $object, args => [$needle] };
+}
+
 # A plain false for the `computed` flag; the evaluator only checks truthiness.
 sub JSON_false { return 0 }
 
@@ -134,6 +139,40 @@ subtest 'boolean-valued ops return JS booleans, not 1/0' => sub {
     ok(!defined $len, '(123).length is null, not 3');
 };
 
+# `.includes` (#2075) is the one `array-method` in the evaluator subset,
+# dispatching on the receiver type like the SSR template lowering does at
+# runtime (`bf_includes` / `$bf->includes`): array → SameValueZero membership
+# (the same value rules as `===`, so a numeric 2 does NOT match the string
+# "2"); string → substring search; anything else degrades to false rather
+# than dying.
+subtest 'array-method includes' => sub {
+    my $hit = BarefootJS::Evaluator::evaluate(nincludes(nid('tags'), nstr('go')), { tags => [ 'perl', 'go' ] });
+    ok(JSON::PP::is_bool($hit), 'array hit is a JS boolean');
+    ok($hit, 'array .includes: hit');
+
+    my $miss = BarefootJS::Evaluator::evaluate(nincludes(nid('tags'), nstr('rust')), { tags => [ 'perl', 'go' ] });
+    ok(JSON::PP::is_bool($miss), 'array miss is a JS boolean');
+    ok(!$miss, 'array .includes: miss');
+
+    # SameValueZero, not loose equality: the numeric element 2 matches the
+    # numeric needle 2, but the string needle "2" (a different JS type) does
+    # not — mirroring `===`'s type-sensitivity.
+    my $num_hit = BarefootJS::Evaluator::evaluate(nincludes(nid('nums'), { kind => 'literal', value => 2 }), { nums => [ 1, 2, 3 ] });
+    ok($num_hit, 'array .includes: numeric element hit');
+    my $num_vs_string = BarefootJS::Evaluator::evaluate(nincludes(nid('nums'), nstr('2')), { nums => [ 1, 2, 3 ] });
+    ok(!$num_vs_string, 'array .includes: numeric element does not match a string needle');
+
+    my $sub = BarefootJS::Evaluator::evaluate(nincludes(nid('name'), nstr('ar')), { name => 'bare' });
+    ok($sub, 'string .includes: substring hit');
+
+    # A non-array, non-string receiver (number, null, object) is not a JS
+    # `.includes` target; the evaluator degrades to false rather than dying.
+    my $scalar_recv = BarefootJS::Evaluator::evaluate(nincludes(nid('n'), { kind => 'literal', value => 1 }), { n => 42 });
+    ok(!$scalar_recv, 'non-collection receiver (number) is false, not a die');
+    my $null_recv = BarefootJS::Evaluator::evaluate(nincludes(nid('n'), nstr('x')), { n => undef });
+    ok(!$null_recv, 'non-collection receiver (null) is false, not a die');
+};
+
 # sort_by tolerates a non-array receiver by returning an empty arrayref (the
 # BarefootJS->sort convention), never undef — so callers can always deref it.
 subtest 'sort_by non-array receiver returns []' => sub {
@@ -262,4 +301,33 @@ subtest 'flat_map projects + flattens one level' => sub {
     is_deeply($fj, [ 'a', 'b', 'c' ], 'flat_map_json decodes + projects');
 };
 
+# #2073: map_items is the value-producing `.map(cb)` — one result per element,
+# NO flatten (an array-valued projection stays one element). Mirrors the Go
+# TestMapEval shapes.
+subtest 'map_items projects one result per element (no flatten)' => sub {
+    my $tmpl = {
+        kind  => 'template-literal',
+        parts => [
+            { type => 'string',     value => '#' },
+            { type => 'expression', expr  => nid('t') },
+        ],
+    };
+    is_deeply(BarefootJS::Evaluator::map_items([ 'perl', 'go' ], $tmpl, 't'),
+        [ '#perl', '#go' ], 'template-literal projection maps each element');
+
+    my @users = ({ name => 'Ada' }, { name => 'Grace' });
+    my $field = nmem(nid('u'), 'name');
+    is_deeply(BarefootJS::Evaluator::map_items(\@users, $field, 'u'),
+        [ 'Ada', 'Grace' ], 'field projection maps each element');
+
+    my @rows = ({ tags => [ 'a', 'b' ] });
+    is_deeply(BarefootJS::Evaluator::map_items(\@rows, nmem(nid('i'), 'tags'), 'i'),
+        [ [ 'a', 'b' ] ], 'array-valued projection stays ONE element (no flatten)');
+
+    # JSON seam.
+    my $mj = BarefootJS::Evaluator::map_json(\@users,
+        JSON::PP->new->encode($field), 'u');
+    is_deeply($mj, [ 'Ada', 'Grace' ], 'map_json decodes + projects');
+};
+
 done_testing;

package/t/helper_vectors.t

@@ -224,10 +224,6 @@ my %DIVERGENCES = (
         expect => '0.3',
         reason => 'Perl stringifies doubles via %.15g',
     },
-    'includes/cross-type probe is strict-equality false' => {
-        expect => 1,
-        reason => 'bf->includes scans with eq (string equality), so 2 eq "2" matches',
-    },
     'filter_truthy/the string "0" is truthy' => {
         expect => ['x'],
         reason => 'Perl truthiness treats the string "0" as false',

package/t/template_primitives.t

@@ -81,11 +81,16 @@ subtest 'floor / ceil / round — Math.* mirrors; propagate NaN' => sub {
 # `Array.prototype.includes(x)` + `String.prototype.includes(sub)` lower
 # to the same `$bf->includes($recv, $elem)` shape — see #1448 Tier A.
 # The Perl helper dispatches on `ref()`: ARRAY ref scans elements with
-# `eq`; scalar falls back to `index(..., ...) != -1`. Anything else
-# (HASH ref, code ref) returns false to match the JS semantic that
-# `.includes` is only defined on Array / TypedArray / String.
+# `BarefootJS::Evaluator::_same_value_zero` (SameValueZero — no cross-type
+# coercion, NaN matches NaN), matching the evaluator's serialized-callback
+# `.includes` path so both positions agree; scalar falls back to
+# `index(..., ...) != -1`. Anything else (HASH ref, code ref) returns
+# false to match the JS semantic that `.includes` is only defined on
+# Array / TypedArray / String.
 subtest 'includes — array + string + non-array/string dispatch' => sub {
-    # Array receiver: element-wise `eq` (handles defined/undef parity).
+    # Array receiver: SameValueZero element search (handles defined/undef
+    # parity, and no numeric/string coercion — see the cross-type cases
+    # below).
     ok  $bf->includes(['a', 'b', 'c'], 'b'), 'array contains element → 1';
     ok !$bf->includes(['a', 'b', 'c'], 'z'), 'array does not contain → 0';
     ok  $bf->includes([1, 2, 3], 2),         'numeric element';
@@ -93,6 +98,12 @@ subtest 'includes — array + string + non-array/string dispatch' => sub {
     ok  $bf->includes([undef, 'a'], undef),  'undef element matches undef needle';
     ok !$bf->includes(['a', 'b'], undef),    'undef needle, no undef element → 0';
 
+    # SameValueZero never coerces across types — pins the divergence from
+    # the old stringy `eq` scan (where `[2].includes("2")` was true).
+    ok !$bf->includes([2], '2'),   '[2].includes("2") → 0 (no numeric→string coercion)';
+    ok  $bf->includes([2], 2),     '[2].includes(2) → 1';
+    ok  $bf->includes(['2'], '2'), '["2"].includes("2") → 1 (string vs string still matches)';
+
     # String receiver: substring search.
     ok  $bf->includes('hello world', 'world'), 'substring present → 1';
     ok !$bf->includes('hello world', 'earth'), 'substring absent → 0';