@barefootjs/mojolicious 0.14.0 → 0.15.0

package/src/test-render.ts

@@ -5,7 +5,7 @@
  * Used by adapter-tests conformance runner.
  */
 
-import { compileJSX, extractSsrDefaults } from '@barefootjs/jsx'
+import { compileJSX, extractSsrDefaults, augmentInheritedPropAccesses, importsSearchParams } from '@barefootjs/jsx'
 import type { ComponentIR } from '@barefootjs/jsx'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
@@ -332,8 +332,12 @@ function buildChildRenderers(
     lines.push(`  close $child_fh;`)
     lines.push(`  my $child_mt = Mojo::Template->new(vars => 1, auto_escape => 1);`)
 
+    lines.push(`  my $defaults_${snakeName} = ${buildChildDefaultsPerl(childIR)};`)
     lines.push(`  $bf->register_child_renderer('${snakeName}', sub {`)
-    lines.push(`    my ($child_props) = @_;`)
+    // `$caller_bf` is the instance whose template invoked render_child
+    // (#1897) — nested children chain their scope identity off it.
+    lines.push(`    my ($child_props, $caller_bf) = @_;`)
+    lines.push(`    my $host_scope = (defined $caller_bf ? $caller_bf->_scope_id : $bf->_scope_id);`)
     // (#1652) A child that destructures a rest-spread bag
     // (`function NativeSelect({ children, ...props })`) emits a
     // template referencing `$<restPropsName>`
@@ -349,8 +353,26 @@ function buildChildRenderers(
     if (childIR.metadata.restPropsName) {
       const rest = childIR.metadata.restPropsName
       lines.push(`    $child_props->{${rest}} = {} unless defined $child_props->{${rest}};`)
+      // (#1897) Route non-param props into the rest bag (JSX rest
+      // semantics): a caller prop the child didn't destructure belongs
+      // in the bag, not as a top-level stash var. Mirrors the Xslate
+      // harness and the production isRestProps branch.
+      const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.name)
+      const keepList = [...new Set([...paramNames, rest, 'children', 'key', '_bf_slot'])]
+        .map(n => `'${n.replace(/[\\']/g, m => `\\${m}`)}'`)
+        .join(', ')
+      lines.push(`    {`)
+      lines.push(`      my %keep = map { $_ => 1 } (${keepList});`)
+      lines.push(`      for my $k (grep { !$keep{$_} } keys %$child_props) {`)
+      lines.push(`        $child_props->{${rest}}{$k} = delete $child_props->{$k};`)
+      lines.push(`      }`)
+      lines.push(`    }`)
     }
     lines.push(`    my $child_bf = BarefootJS->new($c, {});`)
+    // (#1897) Nested `render_child` calls (a child template rendering
+    // another imported component) resolve against THIS instance's
+    // registry — share the parent's so they don't fail.
+    lines.push(`    $child_bf->_child_renderers($bf->_child_renderers);`)
     // JSX `key` (reserved prop) → data-key on the child's scope root, for
     // keyed-loop reconciliation parity with Hono.
     lines.push(`    my $data_key = delete $child_props->{key};`)
@@ -362,11 +384,13 @@ function buildChildRenderers(
     // `<ComponentName>_*`.
     lines.push(`    my $slot = delete $child_props->{_bf_slot};`)
     lines.push(`    if (defined $slot) {`)
-    lines.push(`      $child_bf->_scope_id($bf->_scope_id . "_$slot");`)
+    lines.push(`      $child_bf->_scope_id($host_scope . "_$slot");`)
     lines.push(`    } else {`)
     lines.push(`      $child_bf->_scope_id('${componentName}_' . substr(rand() =~ s/^0\\.//r, 0, 6));`)
     lines.push(`    }`)
-    lines.push(`    my $rendered = $child_mt->render($child_tmpl, { %$child_props, bf => $child_bf });`)
+    // Seed statically-derived defaults under the caller's props (#1897)
+    // so undeclared optional props / signals don't abort strict vars.
+    lines.push(`    my $rendered = $child_mt->render($child_tmpl, { %$defaults_${snakeName}, %$child_props, bf => $child_bf });`)
     lines.push(`    die $rendered->to_string if ref $rendered;`)
     lines.push(`    chomp $rendered;`)
     lines.push(`    return $rendered;`)
@@ -391,6 +415,59 @@ function toSnakeCase(name: string): string {
 /**
  * Build a Perl hash literal from props.
  */
+/**
+ * Statically-derived default template vars for a CHILD component
+ * (#1897): every declared prop (its JSX default or `undef`), inherited
+ * `props.<x>` accesses, signal initial values, and memo ssrDefaults.
+ * Without these, a child template referencing an optional prop the
+ * caller didn't pass (`$id`, `$className`) or its own signal (`$open`)
+ * aborts under Mojo::Template's strict vars. Caller-passed props win at
+ * merge time (`{ %$defaults, %$child_props }`). Mirrors the root-side
+ * seeding in `buildPerlProps` and the production plugin's
+ * `ssrDefaults` consumption.
+ */
+function buildChildDefaultsPerl(ir: ComponentIR): string {
+  // Surface inherited `props.<x>` reads hidden inside template-literal
+  // attr parts / conditional branches as propsParams (idempotent; the
+  // same shared pass the adapters apply — without it TabsContent's
+  // `${props.className ?? ''}` class read never seeds `$className`).
+  augmentInheritedPropAccesses(ir)
+  const entries: string[] = []
+  const declared = new Set<string>()
+  for (const param of ir.metadata.propsParams) {
+    declared.add(param.name)
+    if (param.defaultValue) {
+      const perlValue = jsToPerlValue(param.defaultValue)
+      if (perlValue !== null) {
+        entries.push(`${param.name} => ${perlValue}`)
+        continue
+      }
+    }
+    entries.push(`${param.name} => undef`)
+  }
+  if (ir.metadata.propsObjectName) {
+    for (const name of collectPropsObjectAccesses(ir, ir.metadata.propsObjectName)) {
+      if (declared.has(name)) continue
+      declared.add(name)
+      entries.push(`${name} => undef`)
+    }
+  }
+  for (const signal of ir.metadata.signals) {
+    const value = evaluateSignalInit(signal.initialValue.trim(), undefined)
+    entries.push(`${signal.getter} => ${value !== null ? toPerlLiteral(value) : 'undef'}`)
+  }
+  const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {}
+  for (const memo of ir.metadata.memos) {
+    const entry = ssrDefaults[memo.name]
+    const value =
+      entry && typeof entry === 'object' && 'value' in entry ? entry.value : undefined
+    entries.push(
+      `${memo.name} => ${value !== undefined && value !== null ? toPerlLiteral(value) : 'undef'}`,
+    )
+  }
+  return `{${entries.join(', ')}}`
+}
+
 function buildPerlProps(
   _componentName: string,
   props: Record<string, unknown> | undefined,
@@ -515,12 +592,15 @@ function buildPerlProps(
     }
   }
 
-  // Add signal values evaluated from props (must come after user props)
+  // Add signal values evaluated from props (must come after user props).
+  // Seed `undef` for a null / unevaluable initial (e.g. a
+  // `createSignal<SortKey>(null)` whose getter is read in a child-prop
+  // ternary) rather than skipping it — an unseeded getter faults strict
+  // vars with `Global symbol "$x" requires explicit package name`. Same
+  // rule `buildChildDefaultsPerl` applies to child signals (#1897).
   for (const signal of ir.metadata.signals) {
     const value = evaluateSignalInit(signal.initialValue.trim(), props)
-    if (value !== null) {
-      entries.push(`${signal.getter} => ${toPerlLiteral(value)}`)
-    }
+    entries.push(`${signal.getter} => ${value !== null ? toPerlLiteral(value) : 'undef'}`)
   }
 
   // Add memo values. The production Mojo plugin seeds these from the
@@ -536,6 +616,16 @@ function buildPerlProps(
     entries.push(`${memo.name} => ${toPerlLiteral(value ?? 0)}`)
   }
 
+  // (#1922) Request-scoped `searchParams()`: bind `$searchParams` to an
+  // empty-query reader via the lazy-loading factory (so the render script
+  // needn't `use BarefootJS::SearchParams`). The conformance harness issues no
+  // query string (the production Mojo plugin builds this from
+  // `$c->req->query_params`), so `.get(k)` resolves to undef and the author's
+  // `?? default` renders. Only when the component imports `searchParams`.
+  if (importsSearchParams(ir.metadata)) {
+    entries.push(`searchParams => BarefootJS->search_params('')`)
+  }
+
   return `{${entries.join(', ')}}`
 }