@barefootjs/go-template 0.18.4 → 0.18.7

package/src/test-render.ts

@@ -6,10 +6,12 @@
  */
 
 import { compileJSX } from '@barefootjs/jsx'
-import type { TemplateAdapter, ComponentIR } from '@barefootjs/jsx'
+import type { TemplateAdapter, ComponentIR, ParsedExpr } from '@barefootjs/jsx'
 import { GoTemplateAdapter } from './adapter/go-template-adapter.ts'
 import { deduplicateGoTypes } from './build.ts'
-import { capitalizeFieldName } from './adapter/lib/go-naming.ts'
+import { capitalizeFieldName, goFieldNameForKey, loopKeyToGoFieldPath } from './adapter/lib/go-naming.ts'
+import { findNestedComponents } from './adapter/analysis/component-tree.ts'
+import type { NestedComponentInfo } from './adapter/lib/types.ts'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -157,8 +159,15 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     }
   }
 
-  // Compile parent source
-  const result = compileJSX(source, 'component.tsx', { adapter, outputIR: true })
+  // Compile parent source. `siblingTemplatesRegistered: Boolean(components)`
+  // matches this harness's real behavior — every sibling child template is concatenated
+  // into `tmplContent` and parsed onto one `*template.Template` instance
+  // below, so a loop-body cross-template call resolves at render time (#2205).
+  const result = compileJSX(source, 'component.tsx', {
+    adapter,
+    outputIR: true,
+    siblingTemplatesRegistered: Boolean(components),
+  })
 
   const errors = result.errors.filter(e => e.severity === 'error')
   if (errors.length > 0) {
@@ -319,11 +328,16 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     // cross-adapter; default to 'test' otherwise.
     const rootScopeId = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
 
+    // (#2209 part 2) Route-handler-equivalent seeding for a signal-backed
+    // dynamic child-component loop — see buildDynamicChildLoopSeeding's
+    // docstring.
+    const { lines: dynamicSeedingLines, needsFmt } = buildDynamicChildLoopSeeding(ir, template)
+
     // main.go — render program
     const mainGo = `package main
 
 import (
-	"html/template"
+${needsFmt ? '\t"fmt"\n' : ''}	"html/template"
 	"math/rand"
 	"os"
 
@@ -368,7 +382,7 @@ func main() {
 		ScopeID: ${JSON.stringify(rootScopeId)},
 ${propsInit}
 	})
-	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
+${dynamicSeedingLines.length > 0 ? dynamicSeedingLines.join('\n') + '\n' : ''}	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
 		os.Stderr.WriteString("template error: " + err.Error() + "\\n")
 		os.Exit(1)
 	}
@@ -551,6 +565,95 @@ function ensureMergedStdlibImports(goTypes: string): string {
   return goTypes.replace(/import\s*\([^)]*\)/, newBlock)
 }
 
+/**
+ * Recursively resolve `expr` (a loop's `arrayParsed`) down through
+ * `call`/`member` chains to the base signal getter it reads
+ * (`todos().filter(...)` → `todos`), or `null` when the base isn't a
+ * signal getter call. Structural `ParsedExpr` walk, not string/regex
+ * parsing (see CLAUDE.md's "never parse JS with regex" rule).
+ */
+function findBaseSignalGetter(expr: ParsedExpr | undefined, signalGetters: ReadonlySet<string>): string | null {
+  if (!expr) return null
+  switch (expr.kind) {
+    case 'identifier':
+      return signalGetters.has(expr.name) ? expr.name : null
+    case 'call':
+      return findBaseSignalGetter(expr.callee, signalGetters)
+    case 'member':
+      return findBaseSignalGetter(expr.object, signalGetters)
+    default:
+      return null
+  }
+}
+
+/**
+ * (#2209 part 2) Replicate, in the generated `main.go`, the documented
+ * "the route handler populates the loop-body child-component slice at
+ * request time" contract for a signal-backed dynamic loop —
+ * `generateNewPropsFunction`'s doc comment on `<Name>s []<Name>Props`
+ * in `adapter/go-template-adapter.ts`. The constructor only ever seeds
+ * the loop's DATUM slice (e.g. `.Todos`, straight from the caller's
+ * Input); the child-component Props slice the template actually
+ * ranges over (`.TodoItems`) has no server-side population path in
+ * this harness — the Hono reference materializes it by literally
+ * executing the component, so this closes the gap the same way:
+ * derive each item's child Props from the datum slice, exactly as a
+ * real route handler is documented to.
+ *
+ * Deliberately narrow: only fires for a loop whose (a) array source
+ * resolves, through `call`/`member` chains, to a component signal
+ * getter, (b) generated Go TEMPLATE text actually ranges over
+ * `.<Name>s` (a plain substring check on GENERATED GO OUTPUT — not JS
+ * parsing — so a `/* @client *\/`-marked loop, whose SSR template has
+ * no such range, is untouched by construction), and (c) at least one
+ * child prop is a bare pass-through of the loop item (`todo={todo}`).
+ * Returns the Go statements to splice into `main()` plus whether `fmt`
+ * needs importing.
+ */
+function buildDynamicChildLoopSeeding(
+  ir: ComponentIR,
+  template: string,
+): { lines: string[]; needsFmt: boolean } {
+  const signalGetters = new Set(ir.metadata.signals.map(s => s.getter))
+  const lines: string[] = []
+  let needsFmt = false
+  for (const nested of findNestedComponents(ir.root) as NestedComponentInfo[]) {
+    if (!nested.isDynamic || nested.isPropDerived) continue
+    if (nested.bodyChildren && nested.bodyChildren.length > 0) continue
+    if (!nested.loopParam) continue
+    if (!template.includes(`:= .${nested.name}s}}`)) continue
+    const datumField = findBaseSignalGetter(nested.loopArrayParsed, signalGetters)
+    if (!datumField) continue
+
+    const inputFields: string[] = []
+    for (const prop of nested.props) {
+      if (prop.isEventHandler) continue
+      if (prop.name === 'key' || prop.name.includes('-')) continue
+      if (
+        prop.value.kind === 'expression' &&
+        prop.value.parsed?.kind === 'identifier' &&
+        prop.value.parsed.name === nested.loopParam
+      ) {
+        inputFields.push(`${capitalizeFieldName(prop.name)}: item`)
+      }
+    }
+    if (inputFields.length === 0) continue
+
+    lines.push(`\tprops.${nested.name}s = make([]${nested.name}Props, len(props.${capitalizeFieldName(datumField)}))`)
+    lines.push(`\tfor i, item := range props.${capitalizeFieldName(datumField)} {`)
+    lines.push(`\t\tprops.${nested.name}s[i] = New${nested.name}Props(${nested.name}Input{${inputFields.join(', ')}})`)
+    lines.push(`\t\tprops.${nested.name}s[i].BfParent = props.ScopeID`)
+    lines.push(`\t\tprops.${nested.name}s[i].BfMount = ${JSON.stringify(nested.slotId ?? '')}`)
+    const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
+    if (keyField) {
+      lines.push(`\t\tprops.${nested.name}s[i].BfDataKey = fmt.Sprint(${keyField})`)
+      needsFmt = true
+    }
+    lines.push(`\t}`)
+  }
+  return { lines, needsFmt }
+}
+
 /**
  * Build Go struct field initializers from props.
  */
@@ -572,9 +675,7 @@ function buildGoPropsInit(
   // in struct literal of type InputInput`. (#1467 Phase 2b)
   const declaredParams = new Set((ir?.metadata.propsParams ?? []).map(p => p.name))
   const restPropsName = ir?.metadata.restPropsName ?? null
-  const restBagField = restPropsName
-    ? restPropsName.charAt(0).toUpperCase() + restPropsName.slice(1)
-    : null
+  const restBagField = restPropsName ? capitalizeFieldName(restPropsName) : null
 
   const lines: string[] = []
   const restBagEntries: Array<[string, unknown]> = []
@@ -594,8 +695,9 @@ function buildGoPropsInit(
       restBagEntries.push([key, value])
       continue
     }
-    // Capitalize first letter for Go field name
-    const goField = key.charAt(0).toUpperCase() + key.slice(1)
+    // Same Go-initialism-aware capitalizer as the real adapter (`id` → `ID`,
+    // not the naive `Id`) — see `goMapLiteralFromObject`'s identical fix.
+    const goField = capitalizeFieldName(key)
     if (typeof value === 'string') {
       lines.push(`\t\t${goField}: "${value}",`)
     } else if (typeof value === 'number') {
@@ -729,7 +831,11 @@ function goTypedMapSliceLiteralFromArray(arr: unknown[], elemType: string): stri
 function goStructLiteral(obj: Record<string, unknown>, typeName: string): string {
   const fields: string[] = []
   for (const [k, v] of Object.entries(obj)) {
-    const goField = capitalizeFieldName(k)
+    // `goFieldNameForKey`, not the bare `capitalizeFieldName` — a data-driven
+    // key here can be non-identifier-shaped (`'data-x'`), and the real
+    // adapter's own struct-literal baking (`parsed-literal-to-go.ts`)
+    // sanitizes those to `DataX`, not `Data-x` (Copilot review, #2202).
+    const goField = goFieldNameForKey(k)
     if (typeof v === 'string') fields.push(`${goField}: "${v.replace(/"/g, '\\"')}"`)
     else if (typeof v === 'number' || typeof v === 'boolean') fields.push(`${goField}: ${v}`)
     else if (v === null) fields.push(`${goField}: nil`)
@@ -766,7 +872,19 @@ function goMapLiteralFromObject(
 ): string {
   const entries: string[] = []
   for (const [k, v] of Object.entries(obj)) {
-    const emittedKey = capitalizeKeys ? k.charAt(0).toUpperCase() + k.slice(1) : k
+    // `goFieldNameForKey`, not a naive first-letter uppercase and not the
+    // bare `capitalizeFieldName` — #2168 nested-loop-triple-depth: a naive
+    // capitalize disagrees with the real adapter's Go-initialism-aware
+    // field naming for a key like `id` (naive → "Id", adapter's generated
+    // struct/template field → "ID"), so the harness baked a literal the
+    // template's `{{.ID}}` lookup could never match — the fixture's
+    // rendered fields came back empty at EVERY nesting depth for this
+    // reason, not because of any depth limit. `capitalizeFieldName` alone
+    // fixes the initialism case but still mis-bakes a non-identifier key
+    // (`'data-x'` → `"Data-x"`, not the adapter's own `"DataX"` —
+    // Copilot review, #2202); `goFieldNameForKey` is what the real adapter
+    // uses for exactly this key-to-Go-field sanitization.
+    const emittedKey = capitalizeKeys ? goFieldNameForKey(k) : k
     const key = JSON.stringify(emittedKey)
     if (typeof v === 'string') entries.push(`${key}: "${v.replace(/"/g, '\\"')}"`)
     else if (typeof v === 'number') entries.push(`${key}: ${v}`)