@barefootjs/perl 0.14.0 → 0.15.1

package/lib/BarefootJS/DevReload.pm

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

package/lib/BarefootJS/SearchParams.pm

@@ -0,0 +1,71 @@
+package BarefootJS::SearchParams;
+our $VERSION = "0.14.0";
+use strict;
+use warnings;
+use utf8;
+use feature 'signatures';
+no warnings 'experimental::signatures';
+
+# Request-scoped SSR view of the query string behind the reactive
+# `searchParams()` environment signal (router v0.5, #1922). The framework
+# integration builds one per request from the request URL and threads it into
+# the template scope as `$searchParams` (the camelCase JS name the adapters
+# keep, like every other signal/prop var); the compiled template reads it via
+# `$searchParams->get('key')` (Mojo) / `$searchParams.get('key')` (Xslate).
+#
+# This runtime is template-engine- and framework-agnostic (core Perl only),
+# matching the rest of BarefootJS.pm, so it can ship in the standalone
+# @barefootjs/perl distribution.
+#
+# Semantics mirror the browser's URLSearchParams.get exactly under the
+# adapters' `?? → //` lowering: get() returns the first value for a key, or
+# `undef` when the key is absent. Perl's `//` (defined-or) coalesces only
+# `undef`, so an absent key falls back to the author's default while a
+# present-but-empty value (`?sort=`) keeps the empty string — the same
+# distinction JS `??` draws between `null` and `''`. (This is a closer match
+# than the Go adapter, whose `or` lowering also coalesces the empty string.)
+
+# new($class, $query = '')
+#
+# Parse a raw query string into the reader. A leading '?' is tolerated, '+'
+# decodes to a space, and %XX escapes are decoded — mirroring URLSearchParams's
+# application/x-www-form-urlencoded parsing. A malformed pair never dies; it
+# simply contributes nothing, matching the browser's lenient parsing.
+sub new ($class, $query = '') {
+    $query //= '';
+    $query =~ s/\A\?//;
+    my %values;
+    for my $pair (split /[&;]/, $query) {
+        next if $pair eq '';
+        my ($key, $val) = split /=/, $pair, 2;
+        $key = _decode($key);
+        $val = defined $val ? _decode($val) : '';
+        push @{ $values{$key} }, $val;
+    }
+    return bless { values => \%values }, $class;
+}
+
+# get($self, $key)
+#
+# First value for $key, or `undef` when the key is absent (see the package
+# docstring for why `undef` — not '' — is the right "missing" sentinel under
+# the `//` lowering). A present-but-empty value returns ''.
+sub get ($self, $key) {
+    my $vals = $self->{values}{$key};
+    return undef unless $vals && @$vals;
+    return $vals->[0];
+}
+
+sub _decode ($s) {
+    $s //= '';
+    $s =~ tr/+/ /;
+    # %XX → raw octet, then interpret the octet stream as UTF-8 (what
+    # URLSearchParams does). `utf8::decode` is a core builtin — no CPAN URI /
+    # URI::Escape dependency, keeping this runtime core-Perl-only. A byte run
+    # that isn't valid UTF-8 is left as-is rather than dying (lenient parsing).
+    $s =~ s/%([0-9A-Fa-f]{2})/chr hex $1/ge;
+    utf8::decode($s);
+    return $s;
+}
+
+1;

package/lib/BarefootJS.pm

@@ -1,5 +1,5 @@
 package BarefootJS;
-our $VERSION = "0.13.0";
+our $VERSION = "0.15.0";
 use strict;
 use warnings;
 use utf8;
@@ -103,6 +103,22 @@ sub new ($class, $c, $config = {}) {
     return $self;
 }
 
+# search_params($query = '')
+#
+# Build a request-scoped reader for the reactive searchParams() environment
+# signal (router v0.5, #1922) from a raw query string. Callable as a class or
+# instance method — the invocant is unused.
+#
+# The `require` lives here so consumers (the Mojo plugin, the Xslate host, the
+# test harness, generated render scripts) reach BarefootJS::SearchParams through
+# the BarefootJS object they already hold, never `use`-ing it directly — the
+# same lazy-load seam the Mojo backend uses above. The compiled template reads
+# the returned object via `$searchParams->get('key')`.
+sub search_params ($invocant, $query = '') {
+    require BarefootJS::SearchParams;
+    return BarefootJS::SearchParams->new($query);
+}
+
 # ---------------------------------------------------------------------------
 # Scope & Props
 # ---------------------------------------------------------------------------
@@ -265,6 +281,11 @@ sub register_script ($self, $path) {
 # ---------------------------------------------------------------------------
 # (`_child_renderers` accessor is generated by the minimal accessor base above.)
 
+# Register a renderer for `render_child($name, ...)`. The renderer is
+# invoked as `$renderer->($props_hashref, $invoking_bf)` — unpack `@_`
+# (`my ($props, $caller) = @_;`) instead of declaring a one-argument
+# subroutine signature, which would enforce arity and die on the second
+# argument.
 sub register_child_renderer ($self, $name, $renderer) {
     $self->_child_renderers->{$name} = $renderer;
 }
@@ -287,7 +308,15 @@ sub render_child ($self, $name, @args) {
     # touch children when present" behaviour.
     $props{children} = $self->backend->materialize($props{children})
         if exists $props{children};
-    return $renderer->(\%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
+    # (AccordionTrigger -> ChevronDownIcon), and the grandchild's scope /
+    # slot identity must chain off the CALLER's scope id, not the
+    # registrant's. Renderers unpack `@_` (`my ($props, $caller) = @_;`)
+    # rather than enforcing arity with a one-arg subroutine signature —
+    # see `register_child_renderer`.
+    return $renderer->(\%props, $self);
 }
 
 # ---------------------------------------------------------------------------
@@ -345,7 +374,13 @@ sub register_components_from_manifest ($self, $manifest, %opts) {
         my $signal_init = $signal_inits->{$slot_key};
         my $manifest_defaults = $manifest->{$entry_name}{ssrDefaults};
         $self->register_child_renderer($slot_key, sub {
-            my ($props) = @_;
+            # `$caller` is the instance whose template invoked
+            # `render_child` (#1897) — for a nested render that is a child
+            # instance, and the grandchild's scope/slot identity must chain
+            # off ITS scope id (`root_s0_s0`), not the registrant's.
+            my ($props, $caller) = @_;
+            my $host = $caller // $parent;
+            my $host_scope = $host->_scope_id // $parent_scope;
             # Child shares the parent's backend so nested renders go
             # through the same engine + controller (and inherit any
             # injected json_encoder). The controller is fetched via the weak
@@ -358,16 +393,19 @@ sub register_components_from_manifest ($self, $manifest, %opts) {
             my $data_key = delete $props->{key};
             $child_bf->_data_key($data_key) if defined $data_key;
             $child_bf->_scope_id(
-                $slot_id ? $parent_scope . '_' . $slot_id
+                $slot_id ? $host_scope . '_' . $slot_id
                          : $template_name . '_' . substr(rand() =~ s/^0\.//r, 0, 6)
             );
             $child_bf->_is_child(1);
             # (#1249) Slot identity: host scope + slot id. Emitted as
             # bf-h / bf-m attributes by hydration_attrs.
             if ($slot_id) {
-                $child_bf->_bf_parent($parent_scope);
+                $child_bf->_bf_parent($host_scope);
                 $child_bf->_bf_mount($slot_id);
             }
+            # Share the root registry so the child's own template can
+            # render further imported components (#1897).
+            $child_bf->_child_renderers($parent->_child_renderers);
             $child_bf->_scripts($parent->_scripts);
             $child_bf->_script_seen($parent->_script_seen);
 
@@ -508,6 +546,10 @@ sub number ($self, $value) {
 # portable sentinel check in floor/ceil/round.
 sub _is_nan { my $n = shift; return $n != $n }
 
+# True for +/-Infinity. `9**9**9` is Perl's portable infinity literal; a
+# finite number is always strictly less than +Inf in magnitude.
+sub _is_inf { my $n = shift; return $n == 9**9**9 || $n == -9**9**9 }
+
 sub floor ($self, $value) {
     my $n = $self->number($value);
     return $n if _is_nan($n);
@@ -826,6 +868,27 @@ sub trim ($self, $recv) {
     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";
+# bare `sprintf("%.*f")` would round half-to-even ("2"), diverging. Scale
+# by 10**digits, round with `floor(x + 0.5)` (the same tie-break the
+# `round` helper uses), then format the exact multiple. A negative
+# `digits` clamps to 0, mirroring how the adapters default an omitted
+# argument.
+sub to_fixed ($self, $value, $digits = 0) {
+    my $n = $self->number($value);
+    # JS toFixed returns the STRINGS "NaN" / "Infinity" / "-Infinity" for
+    # non-finite inputs; the numeric values would stringify per-platform
+    # ("nan"/"inf"/...) and diverge.
+    return 'NaN' if _is_nan($n);
+    return $n < 0 ? '-Infinity' : 'Infinity' if _is_inf($n);
+    $digits = 0 if !defined $digits || $digits < 0;
+    my $factor  = 10 ** $digits;
+    my $rounded = POSIX::floor($n * $factor + 0.5);
+    return sprintf('%.*f', $digits, $rounded / $factor);
+}
+
 # `String.prototype.split(sep)` (#1448 Tier B) — string → ARRAY ref.
 #
 # Two JS-parity wrinkles drive the helper (a bare `split` emit would

package/package.json

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

@@ -61,6 +61,7 @@ my %bindings = (
     floor  => sub { $bf->floor($_[0]) },
     ceil   => sub { $bf->ceil($_[0]) },
     round  => sub { $bf->round($_[0]) },
+    to_fixed => sub { $bf->to_fixed(@_) },
 
     # The Mojo renderer emits native lc()/uc(); Xslate emits $bf.lc /
     # $bf.uc. The helper methods wrap CORE::lc/uc, so binding them
@@ -93,6 +94,11 @@ my %bindings = (
     # Mirrors the Mojo inline `[grep { $_ } @{...}]` for filter(Boolean).
     filter_truthy => sub { [grep { $_ } @{ $_[0] }] },
 
+    # searchParams().get(key) (#1922) via the lazy factory consumers use.
+    # No divergence entry: get() returns undef for an absent key (~ JS null)
+    # and '' for present-but-empty, so the Perl backend matches JS exactly.
+    search_params_get => sub { BarefootJS->search_params($_[0])->get($_[1]) },
+
     # Higher-order entries arrive in the canonical projection form
     # (spec: items + field [+ value]); the closures below rebuild the
     # predicate the adapters compile (`i => i.field === value`,

package/t/render_child.t

@@ -0,0 +1,59 @@
+use strict;
+use warnings;
+use utf8;
+
+use Test2::V0;
+
+use lib 'lib';
+use BarefootJS;
+
+# A do-nothing backend: render_child only touches the backend to
+# materialize a `children` prop, which these cases never pass — but
+# `new` eagerly builds the default Mojo backend, which isn't a dependency
+# of this dist's test environment.
+{
+    package StubBackend;
+    sub new { bless {}, shift }
+    sub materialize { $_[1] }
+}
+sub new_bf { BarefootJS->new(undef, { backend => StubBackend->new }) }
+
+# render_child renderer-invocation contract (#1897): the renderer is
+# invoked with ($props_hashref, $invoking_bf) so nested renders can chain
+# scope/slot identity off the caller. Renderers unpack @_ rather than
+# enforcing arity with a one-arg subroutine signature (see
+# register_child_renderer's doc).
+
+subtest 'renderer receives the invoking instance' => sub {
+    my $bf = new_bf();
+    $bf->_scope_id('Root_test');
+
+    my ($seen_props, $seen_caller);
+    $bf->register_child_renderer('probe', sub {
+        my ($props, $caller) = @_;
+        ($seen_props, $seen_caller) = ($props, $caller);
+        return 'ok';
+    });
+
+    is $bf->render_child('probe', value => 1), 'ok', 'renderer output returned';
+    is $seen_props->{value}, 1, 'props forwarded';
+    ref_is $seen_caller, $bf, 'second argument is the invoking instance';
+
+    # A nested invocation from a different instance passes THAT instance.
+    my $child = new_bf();
+    $child->_scope_id('Root_test_s0');
+    $child->_child_renderers($bf->_child_renderers);
+    $child->render_child('probe');
+    ref_is $seen_caller, $child, 'nested call passes the nested instance';
+};
+
+subtest 'renderer exceptions propagate' => sub {
+    my $bf = new_bf();
+    $bf->register_child_renderer('boom', sub {
+        die "renderer exploded\n";
+    });
+    like dies { $bf->render_child('boom') }, qr/renderer exploded/,
+        'renderer errors propagate to the caller';
+};
+
+done_testing;

package/t/search_params.t

@@ -0,0 +1,58 @@
+use Test2::V0;
+use utf8;
+
+# BarefootJS::SearchParams — Perl-specific concerns of the searchParams()
+# environment-signal reader (router v0.5, #1922).
+#
+# The cross-language VALUE semantics of `get` (absent → null/undef, present →
+# first value, repeated keys, present-but-empty, `+`/`%XX`/encoded-separator
+# decoding, first-`=` split) are owned by the language-independent golden
+# vectors — `search_params_get` in packages/adapter-tests/helper-vectors,
+# asserted here via t/helper_vectors.t and in the Go runtime's vectors_test.go,
+# so Go/Perl/JS parity is mechanical. This file covers only what those value
+# vectors can't: the lazy-load factory seam, lenient parsing (never dies), the
+# `//` composition, and UTF-8 decoding.
+
+use FindBin qw($Bin);
+use lib "$Bin/../lib";
+
+use BarefootJS;
+
+# The lazy factory on the BarefootJS object is how every consumer (Mojo plugin,
+# Xslate host, render harness) reaches the reader — no one `use`s the class
+# directly. Assert it loads + builds a working reader.
+subtest 'BarefootJS->search_params lazy factory' => sub {
+    my $sp = BarefootJS->search_params('sort=price');
+    is ref($sp), 'BarefootJS::SearchParams', 'factory returns a reader instance';
+    is $sp->get('sort'), 'price', 'factory-built reader resolves the query';
+    is ref(BarefootJS->search_params), 'BarefootJS::SearchParams', 'default empty query';
+};
+
+# The adapters lower `searchParams().get(k) ?? d` to Perl's defined-or
+# (`$searchParams->get(k) // d`), which coalesces only undef — so an absent key
+# falls back to the default while a present-but-empty value keeps ''. This is
+# the Perl-specific divergence from the Go `or` lowering (which coalesces '').
+subtest '// composition (the ?? lowering) coalesces only undef' => sub {
+    my $absent = BarefootJS->search_params('other=x');
+    is(($absent->get('sort') // 'none'), 'none', 'absent key → author default');
+
+    my $empty = BarefootJS->search_params('sort=');
+    is(($empty->get('sort') // 'none'), '', 'present-but-empty value is kept, NOT defaulted');
+};
+
+# Percent-encoded UTF-8 decodes to characters via the core `utf8::decode`
+# builtin (no URI / URI::Escape dependency) — kept here rather than in the
+# ASCII-only shared vectors to avoid cross-harness byte/char encoding skew.
+subtest 'UTF-8 percent-decoding (core utf8::decode, no URI dep)' => sub {
+    my $sp = BarefootJS->search_params('q=%E2%9C%93');
+    is $sp->get('q'), "\x{2713}", 'percent-encoded UTF-8 → decoded character (✓)';
+};
+
+# Malformed input must degrade, never die (SSR survives junk query strings).
+subtest 'lenient parsing never dies' => sub {
+    ok lives { BarefootJS->search_params(undef) }, 'undef query';
+    ok lives { BarefootJS->search_params('&&&')->get('x') }, 'only separators';
+    ok lives { BarefootJS->search_params('=novalue')->get('x') }, 'empty key pair';
+};
+
+done_testing;