@barefootjs/go-template 0.33.1 → 0.33.3

package/src/adapter/go-template-adapter.ts

@@ -80,7 +80,7 @@ import {
   BindingScope,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
-import { BF_REGION, escapeHtml } from '@barefootjs/shared'
+import { BF_REGION, escapeHtml, resolveJsxChildrenProp } from '@barefootjs/shared'
 
 import {
   GO_IDENTIFIER,
@@ -118,7 +118,6 @@ import type {
   CtorLowerEnv,
   GoTemplateAdapterOptions,
 } from "./lib/types.ts"
-import { collectRootScopeNodes } from "./lib/ir-scope.ts"
 import { GO_TEMPLATE_PRIMITIVES } from "./lib/constants.ts"
 import { CompileState, resolveSignalParsedThroughSeedPlan } from "./lib/compile-state.ts"
 import { hasClientInteractivity, findNestedComponents } from "./analysis/component-tree.ts"
@@ -313,15 +312,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * everywhere except the accessor lookup itself.
    */
   private scope: BindingScope = BindingScope.EMPTY
-  /**
-   * Stack of `IRLoop.depth` values (innermost last), pushed/popped around
-   * `renderChildren(loop.children)` in `renderLoop`. `renderAttributes`
-   * reads the top of this stack to derive the `key` → `data-key`/
-   * `data-key-N` suffix — the depth is IR-computed (jsx-to-ir.ts), not
-   * re-derived here; this stack only threads that value down to the
-   * loop body's root element (#2168 nested-loop-outer-binding).
-   */
-  private loopKeyDepthStack: number[] = []
   /**
    * Per-loop: true when the body renders the bare range value (scalar-item
    * inline-literal loop), so the `bf_tmpl` companion is fed `.BfLoopItem` (the
@@ -521,7 +511,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const isRootComponent = ir.root.type === 'component'
     const isIfStatement = ir.root.type === 'if-statement'
 
-    this.state.rootScopeNodes = collectRootScopeNodes(ir.root)
     // Map each array memo backing a loop (`<memo>().map(...)`) to that loop's
     // handler-filled slice field, so `<memo>().length` lowers to the slice's
     // length. Built before rendering — `.length` can precede the loop in source.
@@ -2323,7 +2312,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           }
           case 'jsx-children':
             // The RESERVED children slot (`comp.children.length > 0 ? comp.children
-            // : jsxChildrenPropNodes(...)`) is handled below via
+            // : resolveJsxChildrenProp(...)`) is handled below via
             // `child.childrenText` / `child.childrenHtml` and must not be
             // re-emitted here. A JSX-valued prop under any OTHER name
             // (`header={<strong>Title</strong>}`, #2168 jsx-element-prop) is a
@@ -3173,17 +3162,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return out
   }
 
-  /**
-   * Pull the IR nodes out of a `children={<…/>}` attribute (a `jsx-children`
-   * prop value). Empty when the component takes no such prop.
-   */
-  private jsxChildrenPropNodes(props: IRProp[]): IRNode[] {
-    for (const p of props) {
-      if (p.value.kind === 'jsx-children') return p.value.children
-    }
-    return []
-  }
-
   private extractHtmlChildren(children: IRNode[]): string | null {
     if (children.length === 0) return null
     if (children.every(c => c.type === 'text')) return null
@@ -3201,10 +3179,33 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * plain static `childrenHtml` path already applies, or when any other template
    * action survives (genuinely dynamic — those stay on the drop path).
    */
+  /**
+   * Set only while baking a hoisted children value into a static Go string.
+   * `data-key` is a KEYED-LOOP-ROW contract, and a value baked into a
+   * caller's props at compile time is by construction not a loop row — so
+   * emitting `{{if .BfDataKey}}` there is dead weight. It is also actively
+   * harmful: `extractScopedHtmlChildren` rejects any surviving `{{` action
+   * as "genuinely dynamic" and returns null, and its caller drops the field
+   * without a word, so the baked children silently vanish.
+   *
+   * `ctx.isRoot` leaks into a JSX-valued prop's subtree, so such a fragment
+   * is already tagged `needsScopeComment` as if it were a component root —
+   * which is why a relay `element.keyAttr` (#2753; `carriesDataKey` before
+   * it) reaches this path at all.
+   */
+  private bakingStaticChildren = false
+
   private extractScopedHtmlChildren(children: IRNode[]): string | null {
     if (children.length === 0) return null
     if (children.every(c => c.type === 'text')) return null
-    const html = this.renderChildren(children)
+    const prevBaking = this.bakingStaticChildren
+    this.bakingStaticChildren = true
+    let html: string
+    try {
+      html = this.renderChildren(children)
+    } finally {
+      this.bakingStaticChildren = prevBaking
+    }
     // The needsScope marker renders parent-scope hydration attrs; in a
     // hoisted fragment every needsScope root resolves to the parent scopeID,
     // so collapse the whole marker to a bare `bf-s` sentinel (the empty
@@ -3252,7 +3253,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // paths below see them.
         const effectiveChildren = comp.children.length > 0
           ? comp.children
-          : this.jsxChildrenPropNodes(comp.props)
+          : resolveJsxChildrenProp(comp.props)
         result.push({
           name: comp.name,
           slotId: comp.slotId,
@@ -4118,12 +4119,34 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker('.ScopeID')}`
     }
-    // A root scope element carries `data-key` for a keyed loop item — the
-    // parent's loop init stamped `.BfDataKey`, so a non-keyed render emits
-    // nothing. Applies to early-return (if-statement) roots too, where every
-    // branch's top element qualifies.
-    if (this.state.rootScopeNodes.has(element) && element.needsScope) {
-      hydrationAttrs += `{{if .BfDataKey}} data-key="{{.BfDataKey}}"{{end}}`
+    // #2753: `element.keyAttr` is the ONE IR-resolved decision for this
+    // element's row-key attribute — replacing both the `carriesDataKey`
+    // boolean and this adapter's own `rootScopeNodes`/`needsScope` check
+    // (mechanism 2: a render-root relay, including the #2732 fragment-root
+    // case) and the separate `loopKeyDepthStack`-driven rewrite of a literal
+    // `key` attribute this adapter used to do in `renderAttributes`
+    // (mechanism 1: a `.map()` row root compiled inline here).
+    if (element.keyAttr) {
+      if (element.keyAttr.value !== undefined) {
+        const lowered = emitAttrValue(
+          { kind: 'expression', expr: element.keyAttr.value },
+          this.elementAttrEmitter,
+          element.keyAttr.name,
+        )
+        if (lowered) hydrationAttrs += ` ${lowered}`
+      } else if (!this.bakingStaticChildren) {
+        // Relay: this element is one of THIS component's own render roots,
+        // carrying whatever key its OWN caller supplies at runtime (the
+        // parent's loop init stamped `.BfDataKey`), when this component is
+        // itself invoked as a caller's keyed loop row. Applies to
+        // early-return (if-statement) roots too, where every branch's top
+        // element qualifies, and to #2732's fragment-root case.
+        // `bakingStaticChildren` (see its docstring) excludes a hoisted
+        // children value baked into a static Go string at compile time —
+        // by construction not a loop row, and a surviving `{{if}}` action
+        // there gets silently dropped by the caller rather than rendered.
+        hydrationAttrs += `{{if .BfDataKey}} data-key="{{.BfDataKey}}"{{end}}`
+      }
     }
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`
@@ -7139,7 +7162,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null,
     )
     this.loopWrapperStack.push(!!loop.childComponent)
-    this.loopKeyDepthStack.push(loop.depth)
     // Rendered inside the pushed loop scope so each initializer resolves
     // against the range item (`.Done`), in source order so a later
     // initializer sees an earlier `$` variable — same as the source block.
@@ -7147,7 +7169,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       .map(d => `{{$${d.name} := ${this.renderParsedExpr(d.valueParsed)}}}`)
       .join('')
     const children = this.renderChildren(loop.children)
-    this.loopKeyDepthStack.pop()
     this.loopWrapperStack.pop()
     this.loopScalarItemStack.pop()
     // Build the per-item anchor marker while the row scope is still active,
@@ -7239,7 +7260,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const wasInLoopOuter = this.inLoop
     this.inLoop = true
     this.loopWrapperStack.push(false)
-    this.loopKeyDepthStack.push(loop.depth)
     this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null)
     // The bake gate (`analyzeBakeableStaticElementLoop`) already refused a
     // destructured or `.keys()`-shape param, so `loop` binds via `enterLoopRow`
@@ -7272,7 +7292,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     this.scope = prevScope
     this.loopScalarItemStack.pop()
-    this.loopKeyDepthStack.pop()
     this.loopWrapperStack.pop()
     this.inLoop = wasInLoopOuter
 
@@ -7308,7 +7327,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private queueDynamicChildrenDefine(comp: IRComponent): string | null {
     const effectiveChildren = comp.children.length > 0
       ? comp.children
-      : this.jsxChildrenPropNodes(comp.props)
+      : resolveJsxChildrenProp(comp.props)
     if (effectiveChildren.length === 0) return null
     if (this.extractTextChildren(effectiveChildren) !== null) return null
     if (this.extractHtmlChildren(effectiveChildren) !== null) return null
@@ -7335,7 +7354,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private queueLoopBodyChildrenDefine(comp: IRComponent): string | null {
     const effectiveChildren = comp.children.length > 0
       ? comp.children
-      : this.jsxChildrenPropNodes(comp.props)
+      : resolveJsxChildrenProp(comp.props)
     if (effectiveChildren.length === 0) return null
     if (this.extractTextChildren(effectiveChildren) !== null) return null
     if (this.extractHtmlChildren(effectiveChildren) !== null) return null
@@ -7718,19 +7737,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // literal never reaches the generic object-literal BF101 refusal
       // (which would double-report alongside the purpose-built one).
       if (isDangerousInnerHtmlAttr(attr)) continue
-      // Rewrite JSX special-prop names to their HTML-attribute counterparts. The
-      // Go template adapter has no JSX runtime to strip `key` / emit `data-key`,
-      // so the rewrite happens at attribute-emit time. Mirror of the `key`
-      // branch in `ir-to-client-js/html-template.ts`. The depth-suffix (plain
-      // `data-key` at the outermost loop, `data-key-N` N levels deep) comes
-      // from `IRLoop.depth` via `loopKeyDepthStack`, not re-derived here.
-      let attrName: string
-      if (attr.name === 'className') attrName = 'class'
-      else if (attr.name === 'key') {
-        const depth = this.loopKeyDepthStack.at(-1) ?? 0
-        attrName = depth > 0 ? `data-key-${depth}` : 'data-key'
-      }
-      else attrName = attr.name
+      // `key` never renders as a literal HTML attribute — #2753 resolves it
+      // onto `element.keyAttr` (name AND value) at IR-build time, emitted
+      // separately in `renderElement`. A stray `key` that jsx-to-ir.ts did
+      // NOT recognize as a loop row root (so `keyAttr` was never set) has no
+      // defined rendering outside a `.map()` anyway; drop it rather than
+      // leak an invalid `key="..."` HTML attribute.
+      if (attr.name === 'key') continue
+      // Rewrite JSX special-prop names to their HTML-attribute counterparts.
+      const attrName = attr.name === 'className' ? 'class' : attr.name
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName)
       if (lowered) parts.push(lowered)
     }

package/src/adapter/lib/compile-state.ts

@@ -19,7 +19,6 @@ import type {
   ContextConsumer,
   EnvSignalReader,
   IRMetadata,
-  IRNode,
   LoweringMatcher,
   MemoInfo,
   ParsedExpr,
@@ -205,10 +204,6 @@ export class CompileState {
    */
   stringValueNames: Set<string> = new Set()
 
-  /** Component root scope element(s) — each carries `data-key` for a keyed loop
-   *  item. */
-  rootScopeNodes: Set<IRNode> = new Set()
-
   /** Array-memo name → the handler-filled loop slice field its `.map()` feeds
    *  (e.g. `visible` → `PostListItems`). Lets `<memo>().length` lower to the
    *  slice's length instead of a nil/unset memo field. */

package/src/render-divergences.ts

@@ -20,6 +20,10 @@ import type { RenderDivergences } from '@barefootjs/jsx'
 export const renderDivergences: RenderDivergences = {
   'jsx-element-prop-fragment-conditional':
     'Go-specific half of the fragment-wrapped-conditional prop shape, tracked as https://github.com/piconic-ai/barefootjs/issues/2703 (distinct from #2702, the cross-adapter hydrate-time bug). #2702 is a hydrate-time-only bug (SSR is correct on every adapter, confirmed for Go by direct `adapter.generate()` inspection of the raw template TEXT, which does contain `{{if .Cond}}<a bf-c="^s0">x</a>{{else}}...{{end}}`-shaped markup). But the REAL Go render of this exact fixture (`go-template-adapter.test.ts`, real `go run`) produces an EMPTY `<header>` — `<header bf="s1"><!--bf:s0--><!--/--></header>` instead of the reference `<a>x</a>` — i.e. the `header` prop\'s jsx-children payload never reaches the child (`Card`) component\'s slot construction (`.CardSlot1`) at all for this NAMED-prop shape, even though the same conditional-in-fragment payload renders correctly when passed via `children` instead (`jsx-element-prop-children-escape`). Root cause not yet isolated to a specific emitter function — only the reproducible symptom is pinned here. Every other adapter (Hono, ERB, Jinja, Mojolicious, MiniJinja, Twig, Xslate, Blade) renders this fixture correctly; verified by running each adapter\'s own JSX Conformance Tests for this fixture id.',
+  'children-passthrough-renamed':
+    'A `children` prop destructured under a different name (`const { children: kids } = props`) does not reach the SSR template on Go, tracked as https://github.com/piconic-ai/barefootjs/issues/2788. The same fixture also fails on Mojolicious, where the mechanism IS isolated: the `.html.ep` interpolates the LOCAL alias (`$kids`) while the stash defines only the caller-facing `children`, so the Perl render dies inside `Mojo::Template::process`. Go\'s own failure mode has NOT been read — `go` is not reachable from the local test process (the conformance case prints "go command not found" and skips), so this entry is declared from the CI failure on #2787 alone, not from a local reproduction. Whoever graduates this should read Go\'s actual output first rather than assume it shares Mojo\'s mechanism. Same alias family as `aliased-destructured-prop` (`{ n: count }`), whose Go half graduated in #2525 — worth checking whether the reserved `children` slot bypasses that fix or never had it. `children-passthrough-renamed` asserts the CORRECT (Hono-generated) output, so deleting this entry is the graduation.',
   'signal-object-spread-init':
     'PRE-EXISTING, unrelated to the #2696 Step 2 spread work this fixture pins: a `derived`-classified signal/memo whose value is an OBJECT literal has no live-template-expression lowering on Go — unlike the other six template-stash backends (e.g. minijinja emits `{% set merged = dict(base, done=true) %}`), Go always bakes an object-typed signal/memo field into Go SOURCE at `NewXxxProps` constructor time (`convertInitialValue`/`parsedLiteralToGo`), and that baker is STATIC-only (identifier/call/member operands defer, `parsed-literal-to-go.ts`\'s own docstring) — it cannot reference a live prop at all. Reproduced identically with the spread REMOVED (`createSignal({ id: base.id, done: true })`), confirming the gap predates and is independent of spread: the signal seeds `nil` and every field read (`.Merged.ID`/`.Merged.Done`) reads the Go zero value regardless of `initialTodos`. Graduate by teaching the baker to emit prop-referencing Go expressions (https://github.com/piconic-ai/barefootjs/issues/2700).',
+  'textarea-row-breakout':
+    'A signal seeded from a bare identifier referencing a MODULE-LEVEL const (`const PAYLOAD = \'...\'; createSignal(PAYLOAD)`) bakes to `nil` in the generated `New<Component>Props` constructor instead of the const\'s literal value: `convertInitialValue` (`value-lowering.ts`) only resolves a direct prop reference or a literal expression for a bare identifier, and the analyzer types this signal `{ kind: \'unknown\' }`, so every typed branch falls through to the final `nil` fallback. `resolveModuleStringConst` exists on the adapter for exactly this resolution (used by `template-interp.ts` for live template expressions) but isn\'t wired into this signal-baking path. Unrelated to what this fixture exists to cover (#2765\'s loop-row textarea-escaping fix, verified correct here) — every other adapter renders the fixture\'s controlled `<textarea>` correctly. Tracked at https://github.com/piconic-ai/barefootjs/issues/2794; graduate by wiring `resolveModuleStringConst` into `convertInitialValue`\'s bare-identifier case.',
 }

package/dist/adapter/lib/ir-scope.d.ts

@@ -1,13 +0,0 @@
-/**
- * IR traversal helpers for the Go html/template adapter. Pure functions over
- * the IR tree — no adapter instance state.
- */
-import type { IRNode } from '@barefootjs/jsx';
-/**
- * Collect the component's root scope element node(s) — the elements that become
- * the rendered root and so carry `data-key` for a keyed loop item. A plain
- * element root is itself; an `if-statement` (early-return) root contributes the
- * top element of each branch, since exactly one renders at runtime.
- */
-export declare function collectRootScopeNodes(node: IRNode): Set<IRNode>;
-//# sourceMappingURL=ir-scope.d.ts.map

package/dist/adapter/lib/ir-scope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ir-scope.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/ir-scope.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAA6B,MAAM,iBAAiB,CAAA;AAExE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAiB/D"}

package/src/adapter/lib/ir-scope.ts

@@ -1,31 +0,0 @@
-/**
- * IR traversal helpers for the Go html/template adapter. Pure functions over
- * the IR tree — no adapter instance state.
- */
-
-import type { IRNode, IRIfStatement, IRFragment } from '@barefootjs/jsx'
-
-/**
- * Collect the component's root scope element node(s) — the elements that become
- * the rendered root and so carry `data-key` for a keyed loop item. A plain
- * element root is itself; an `if-statement` (early-return) root contributes the
- * top element of each branch, since exactly one renders at runtime.
- */
-export function collectRootScopeNodes(node: IRNode): Set<IRNode> {
-  const out = new Set<IRNode>()
-  const visit = (n: IRNode | null): void => {
-    if (!n) return
-    if (n.type === 'element') { out.add(n); return }
-    if (n.type === 'if-statement') {
-      const s = n as IRIfStatement
-      visit(s.consequent)
-      visit(s.alternate)
-      return
-    }
-    if (n.type === 'fragment') {
-      for (const c of (n as IRFragment).children) visit(c)
-    }
-  }
-  visit(node)
-  return out
-}