@barefootjs/perl 0.18.4 → 0.18.5

package/lib/BarefootJS/DevReload.pm

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

package/lib/BarefootJS.pm

@@ -1,5 +1,5 @@
 package BarefootJS;
-our $VERSION = "0.18.3";
+our $VERSION = "0.18.4";
 use strict;
 use warnings;
 use utf8;
@@ -303,16 +303,17 @@ sub render_child ($self, $name, @args) {
     # Template languages whose method calls can't splat a hash into positional
     # args (Text::Xslate Kolon, Template Toolkit) pass one hashref instead.
     my %props = (@args == 1 && ref $args[0] eq 'HASH') ? %{ $args[0] } : @args;
-    # JSX children come in via the engine's children-capture mechanism
-    # (Mojo's `begin %>...<% end`, which produces a CODE ref returning a
-    # Mojo::ByteStream). Materialize it through the backend before handing
-    # the props to the child renderer so the child template sees
-    # `$children` as already-rendered HTML. Guard on `exists` so a
-    # childless invocation (`bf->render_child('counter')`) doesn't gain a
-    # spurious `children => undef` key — preserving the historical "only
-    # touch children when present" behaviour.
-    $props{children} = $self->backend->materialize($props{children})
-        if exists $props{children};
+    # JSX children AND any other named JSX-valued slot (`header={<strong/>}`,
+    # #2168 jsx-element-prop) come in via the engine's children-capture
+    # mechanism (Mojo's `begin %>...<% end`, which produces a CODE ref
+    # returning a Mojo::ByteStream). Materialize every prop value through
+    # the backend before handing the props to the child renderer, so the
+    # child template sees each slot as already-rendered HTML rather than a
+    # bare CODE ref — `materialize` is a no-op for a value that isn't a
+    # CODE ref (see e.g. `BarefootJS::Backend::Mojo::materialize`), so this
+    # is safe to apply unconditionally rather than naming `children`
+    # specifically.
+    $props{$_} = $self->backend->materialize($props{$_}) for keys %props;
     # Renderer contract (#1897): the renderer is invoked with TWO
     # arguments — the props hashref and the INVOKING instance. A renderer
     # registered on the root may be called from a nested child render
@@ -627,6 +628,32 @@ sub round ($self, $value) {
     return POSIX::floor($n + 0.5);
 }
 
+# `Math.min(a, b)` / `Math.max(a, b)` -- two-arg forms only (#2168
+# math-methods). JS returns NaN if either operand is NaN.
+sub min ($self, $a, $b) {
+    my $x = $self->number($a);
+    my $y = $self->number($b);
+    return $x if _is_nan($x);
+    return $y if _is_nan($y);
+    return $x < $y ? $x : $y;
+}
+
+sub max ($self, $a, $b) {
+    my $x = $self->number($a);
+    my $y = $self->number($b);
+    return $x if _is_nan($x);
+    return $y if _is_nan($y);
+    return $x > $y ? $x : $y;
+}
+
+# `Math.abs()` (#2168 math-methods). `CORE::abs` avoids Perl's
+# ambiguous-call warning against this package's own `abs` sub.
+sub abs ($self, $value) {
+    my $n = $self->number($value);
+    return $n if _is_nan($n);
+    return CORE::abs($n);
+}
+
 # ---------------------------------------------------------------------------
 # Array / String method helpers (#1448 Tier A)
 # ---------------------------------------------------------------------------
@@ -800,22 +827,39 @@ sub concat ($self, $a, $b) {
     return \@out;
 }
 
-# `Array.prototype.slice(start, end?)` — carves out a sub-range
-# into a new ARRAY ref. Mirrors the Go `bf_slice` arithmetic so
-# adapter output stays symmetric:
+# `Array.prototype.slice(start, end?)` AND `String.prototype.slice`
+# (the `string-slice` divergence) — carves out a sub-range. The
+# adapter emits the same call for both receiver shapes (it can't
+# disambiguate string vs. array at compile time), so this dispatches
+# at runtime on `ref($recv)`, mirroring `includes` above. Mirrors the
+# Go `bf_slice` arithmetic so adapter output stays symmetric:
 #   - start < 0          → length + start  (e.g. -1 = last index)
 #   - end < 0            → length + end
 #   - start < 0 after clamp → 0
 #   - end > length       → length
 #   - start >= end       → empty
 #   - end undef          → "to length"
-# Non-array receivers return an empty ARRAY ref.
+# String length/positions are characters (`use utf8` is active), not
+# bytes. Any other receiver returns an empty ARRAY ref.
 
 sub slice ($self, $recv, $start, $end) {
+    if (!ref($recv) && defined $recv) {
+        my $len = CORE::length($recv);
+        my ($s, $e) = _clamp_slice_range($len, $start, $end);
+        return '' if $s >= $e;
+        return substr($recv, $s, $e - $s);
+    }
     return [] unless ref($recv) eq 'ARRAY';
     my $len = scalar @$recv;
     return [] if $len == 0;
 
+    my ($s, $e) = _clamp_slice_range($len, $start, $end);
+    return [] if $s >= $e;
+    return [ @{$recv}[$s .. $e - 1] ];
+}
+
+# Shared bounds arithmetic for both `slice` branches above.
+sub _clamp_slice_range ($len, $start, $end) {
     my $s = $start // 0;
     $s = $len + $s if $s < 0;
     $s = 0    if $s < 0;
@@ -826,8 +870,7 @@ sub slice ($self, $recv, $start, $end) {
     $e = 0    if $e < 0;
     $e = $len if $e > $len;
 
-    return [] if $s >= $e;
-    return [ @{$recv}[$s .. $e - 1] ];
+    return ($s, $e);
 }
 
 # `Array.prototype.reverse()` / `Array.prototype.toReversed()` —
@@ -979,6 +1022,26 @@ sub trim ($self, $recv) {
     return $s;
 }
 
+# `String.prototype.trimStart()` / `.trimEnd()` — the one-sided
+# siblings of `trim` above (#2183 follow-up), same `\s` /u regex
+# semantics restricted to one side.
+
+sub trim_start ($self, $recv) {
+    return '' unless defined $recv;
+    return '' if ref($recv);
+    my $s = "$recv";
+    $s =~ s/^\s+//u;
+    return $s;
+}
+
+sub trim_end ($self, $recv) {
+    return '' unless defined $recv;
+    return '' if ref($recv);
+    my $s = "$recv";
+    $s =~ s/\s+$//u;
+    return $s;
+}
+
 # `Number.prototype.toFixed(digits)` (#1897) — fixed-decimal string with
 # zero-padding. JS rounds the scaled integer half toward +Infinity (the
 # spec's "pick the larger n" tie-break), so `(2.5).toFixed(0)` is "3";
@@ -1121,6 +1184,33 @@ sub replace ($self, $recv, $pattern, $replacement) {
     return substr($s, 0, $i) . $n . substr($s, $i + CORE::length($o));
 }
 
+# `String.prototype.replaceAll(pattern, replacement)` — string-pattern
+# form only (#2182), replacing EVERY occurrence (the all-occurrences
+# sibling of `replace` above). Same literal-splice approach (no regex
+# metacharacters, no `$1`/`$&` interpolation) as `replace`, looped
+# forward from each match's end. An empty pattern inserts the
+# replacement at every boundary, including before the first and after
+# the last character (`"abc".replaceAll("", "X")` -> "XaXbXcX"),
+# matching JS.
+
+sub replace_all ($self, $recv, $pattern, $replacement) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+    my $o = defined $pattern ? "$pattern" : '';
+    my $n = defined $replacement ? "$replacement" : '';
+    return CORE::join($n, '', split(//, $s), '') if $o eq '';
+    my $out = '';
+    my $pos = 0;
+    my $olen = CORE::length($o);
+    while (1) {
+        my $i = index($s, $o, $pos);
+        last if $i < 0;
+        $out .= substr($s, $pos, $i - $pos) . $n;
+        $pos = $i + $olen;
+    }
+    $out .= substr($s, $pos);
+    return $out;
+}
+
 # `queryHref(base, { … })` (#2042) — build `"$base?k=v&…"` from a flat list of
 # (guard, key, value) triples. A pair is included iff its guard is truthy AND
 # its value is a non-empty string, mirroring the client `queryHref`'s `if

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/perl",
-  "version": "0.18.4",
+  "version": "0.18.5",
   "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/helper_vectors.t

@@ -87,6 +87,9 @@ my %bindings = (
     floor  => sub { $bf->floor($_[0]) },
     ceil   => sub { $bf->ceil($_[0]) },
     round  => sub { $bf->round($_[0]) },
+    min    => sub { $bf->min($_[0], $_[1]) },
+    max    => sub { $bf->max($_[0], $_[1]) },
+    abs    => sub { $bf->abs($_[0]) },
     to_fixed => sub { $bf->to_fixed(@_) },
 
     # The Mojo renderer emits native lc()/uc(); Xslate emits $bf.lc /
@@ -95,9 +98,12 @@ my %bindings = (
     lower       => sub { $bf->lc($_[0]) },
     upper       => sub { $bf->uc($_[0]) },
     trim        => sub { $bf->trim($_[0]) },
+    trim_start  => sub { $bf->trim_start($_[0]) },
+    trim_end    => sub { $bf->trim_end($_[0]) },
     starts_with => sub { $bf->starts_with(@_) },
     ends_with   => sub { $bf->ends_with(@_) },
     replace     => sub { $bf->replace(@_) },
+    replace_all => sub { $bf->replace_all(@_) },
     repeat      => sub { $bf->repeat(@_) },
     pad_start   => sub { $bf->pad_start(@_) },
     pad_end     => sub { $bf->pad_end(@_) },

package/t/template_primitives.t

@@ -78,6 +78,28 @@ subtest 'floor / ceil / round — Math.* mirrors; propagate NaN' => sub {
     ok is_nan($bf->round('not')), 'round: NaN propagates';
 };
 
+# `Math.min(a, b)` / `Math.max(a, b)` (two-arg forms only) and
+# `Math.abs()` (#2168 math-methods). JS returns NaN if EITHER min/max
+# operand is NaN.
+subtest 'min / max / abs — Math.* mirrors; propagate NaN' => sub {
+    is $bf->min(3, 7),    3, 'min(3, 7) → 3';
+    is $bf->min(7, 3),    3, 'min(7, 3) → 3 (order-independent)';
+    is $bf->min(-2, -5), -5, 'min(-2, -5) → -5';
+    ok is_nan($bf->min('not', 5)), 'min: NaN in first arg propagates';
+    ok is_nan($bf->min(5, 'not')), 'min: NaN in second arg propagates';
+
+    is $bf->max(3, 7),    7, 'max(3, 7) → 7';
+    is $bf->max(7, 3),    7, 'max(7, 3) → 7 (order-independent)';
+    is $bf->max(-2, -5), -2, 'max(-2, -5) → -2';
+    ok is_nan($bf->max('not', 5)), 'max: NaN in first arg propagates';
+    ok is_nan($bf->max(5, 'not')), 'max: NaN in second arg propagates';
+
+    is $bf->abs(-7.6), 7.6, 'abs(-7.6) → 7.6';
+    is $bf->abs(7.6),  7.6, 'abs(7.6) → 7.6 (no-op)';
+    is $bf->abs(0),    0,   'abs(0) → 0';
+    ok is_nan($bf->abs('not')), 'abs: NaN propagates';
+};
+
 # `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
@@ -189,7 +211,7 @@ subtest 'concat — merges two arrays into a new array ref' => sub {
 # into a new ARRAY ref (#1448 Tier A). Mirrors the Go `bf_slice`
 # JS-compat semantics: negative-index normalisation, out-of-bounds
 # clamping, `start >= end` returns empty, undef `end` means "to
-# length". Non-array receivers return an empty ARRAY ref.
+# length". Non-array, non-string receivers return an empty ARRAY ref.
 subtest 'slice — array sub-range with negative-index + clamping' => sub {
     my $arr = ['a', 'b', 'c', 'd', 'e'];
 
@@ -213,7 +235,7 @@ subtest 'slice — array sub-range with negative-index + clamping' => sub {
     # Edge cases.
     is $bf->slice([],     0, undef), [],                   'empty array → empty';
     is $bf->slice(undef,  0, undef), [],                   'undef receiver → empty';
-    is $bf->slice('scalar', 0, undef), [],                 'scalar receiver → empty';
+    is $bf->slice({foo => 1}, 0, undef), [],                'hashref receiver → empty (not array, not string)';
 
     # Mutation isolation.
     my $src = ['a', 'b', 'c'];
@@ -222,6 +244,22 @@ subtest 'slice — array sub-range with negative-index + clamping' => sub {
     is $src, ['a', 'b', 'c'], 'source unchanged after mutating slice result';
 };
 
+# `String.prototype.slice(start, end?)` — the `string-slice`
+# divergence (#2182): a scalar receiver used to fall through the
+# array-only branch above and return an empty ARRAY ref instead of a
+# substring. Mirrors the array subtest's shape with a string receiver.
+subtest 'slice — string sub-range with negative-index + clamping' => sub {
+    my $word = 'barefootjs';
+
+    is $bf->slice($word, 0, 4),      'bare',   'start+end carves the prefix';
+    is $bf->slice($word, -4, undef), 'otjs',   'negative start counts from the end';
+    is $bf->slice($word, 4, undef),  'footjs', 'undef end → to length';
+    is $bf->slice($word, 5, 2),      '',       'start > end → empty string';
+
+    # Multi-byte: index by character, not byte.
+    is $bf->slice('héllo', 0, 2), 'hé', 'multi-byte characters count as one unit each';
+};
+
 # `Array.prototype.reverse()` / `Array.prototype.toReversed()` —
 # both shapes share the lowering (#1448 Tier A). SSR templates
 # render a snapshot, so JS's mutate-vs-new distinction has no
@@ -267,6 +305,33 @@ subtest 'trim — strip leading + trailing whitespace' => sub {
     is $bf->trim(42),                  '42',             'numeric receiver stringifies';
 };
 
+# `String.prototype.trimStart()` / `.trimEnd()` — the one-sided
+# siblings of `trim` above (#2183). Padding BOTH sides of the test
+# input so a swapped side (or a routed-through-both-sides regression)
+# fails visibly.
+subtest 'trim_start / trim_end — strip only their own side' => sub {
+    is $bf->trim_start('   padded   '), 'padded   ',  'trim_start leaves trailing spaces';
+    is $bf->trim_end('   padded   '),   '   padded',  'trim_end leaves leading spaces';
+
+    is $bf->trim_start("\t\nleading"),  'leading',    'trim_start strips tab + newline';
+    is $bf->trim_end('trailing  '),     'trailing',   'trim_end strips trailing spaces';
+
+    is $bf->trim_start('no-pad'),       'no-pad',     'trim_start no-op passthrough';
+    is $bf->trim_end('no-pad'),         'no-pad',     'trim_end no-op passthrough';
+
+    is $bf->trim_start('   '),          '',           'trim_start all whitespace → empty';
+    is $bf->trim_end('   '),            '',           'trim_end all whitespace → empty';
+
+    is $bf->trim_start(''),             '',           'trim_start empty input → empty';
+    is $bf->trim_end(''),               '',           'trim_end empty input → empty';
+
+    # Non-string receivers.
+    is $bf->trim_start(undef),          '',           'trim_start undef receiver → empty';
+    is $bf->trim_end(undef),            '',           'trim_end undef receiver → empty';
+    is $bf->trim_start({a => 1}),       '',           'trim_start hash ref receiver → empty';
+    is $bf->trim_end(['arr']),          '',           'trim_end array ref receiver → empty';
+};
+
 # `String.prototype.split(sep)` — string → ARRAY ref (#1448 Tier B).
 # Mirrors the Go `bf_split`: literal (quotemeta'd) separator, trailing
 # empties preserved (the `-1` limit), empty-separator char split.