@barefootjs/go-template 0.32.0 → 0.33.1

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

@@ -58,6 +58,7 @@ import {
   asCallbackMethodCall,
   sortComparatorFromArrow,
   emitParsedExpr,
+  groupObjectLiteralSegments,
   emitIRNode,
   emitAttrValue,
   augmentInheritedPropAccesses,
@@ -1370,6 +1371,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (el.kind !== 'object-literal') return null
       const seen = new Set<string>()
       for (const prop of el.properties) {
+        // A spread (`{ ...t, a: 1 }`, #2696 Step 2) isn't a plain per-key
+        // scalar shape this fast path bakes — fall back (the caller's
+        // `ts.createSourceFile` path, or refusal) rather than mis-baking.
+        if (prop.kind === 'spread') return null
         if (prop.shorthand) return null
         const key = prop.key
         if (!GO_IDENTIFIER.test(key)) return null
@@ -3401,6 +3406,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (parsed.kind !== 'object-literal') return null
     const entries: string[] = []
     for (const prop of parsed.properties) {
+      // A spread (`{ ...t }`, #2696 Step 2) isn't a per-key member this Go
+      // struct-literal lowering can express — fail the whole value, same as
+      // any other unsupported member (the consumer keeps its default).
+      if (prop.kind === 'spread') return null
       if (prop.shorthand) return null
       const goVal = this.lowerProviderMapMemberValue(prop.value, propsParams)
       if (goVal === null) return null
@@ -4991,12 +5000,33 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `bf_arr ${parts.join(' ')}`
   }
 
-  objectLiteral(_properties: ObjectLiteralProperty[], raw: string, _emit: (e: ParsedExpr) => string): string {
-    // The shared `isSupported` gate now admits an EMPTY object literal
-    // (`?? {}`) as `??`'s right operand (expression-parser.ts, `logical`
-    // case) — every other adapter has a native `{}` dict/hashref literal to
-    // emit here, but `text/template` has none, so this dispatcher is the
-    // one place left to refuse the shape. Unlike the sibling adapters, Go
+  objectLiteral(properties: ObjectLiteralProperty[], raw: string, emit: (e: ParsedExpr) => string): string {
+    // A POPULATED literal is reachable here only in VALUE position (a
+    // `.map()` receiver/callback body, an array-literal element, …) —
+    // `isSupportedValue` admits it when every property value is itself
+    // supported (expression-parser.ts, `checkSupport`'s `pos` parameter).
+    // `text/template` has no map-literal syntax, so lower through the
+    // variadic `bf_map` runtime helper (the object counterpart of
+    // `arrayLiteral`'s `bf_arr`) instead of trying to spell a literal.
+    if (properties.length > 0) {
+      const wrap = (rendered: string) => (rendered.includes(' ') ? `(${rendered})` : rendered)
+      const literalOf = (run: readonly Extract<ObjectLiteralProperty, { kind: 'prop' }>[]) =>
+        `bf_map ${run.map(p => `"${escapeGoString(p.key)}" ${wrap(emit(p.value))}`).join(' ')}`
+      if (!properties.some(p => p.kind === 'spread')) {
+        return literalOf(properties as Extract<ObjectLiteralProperty, { kind: 'prop' }>[])
+      }
+      // Spread (`{ ...t, editing: false }`, #2696 Step 2): `bf_merge`
+      // (runtime/eval.go, a `bf_map` sibling) is a variadic, null-safe map
+      // merge — a non-map argument (nil included) is skipped rather than
+      // panicking, matching JS's null/undefined-spread no-op — folding
+      // every segment (a `bf_map` run, or a spread's own emitted value) in
+      // ONE call, later segments winning, exactly JS spread's semantics.
+      const segments = groupObjectLiteralSegments(properties, literalOf, e => wrap(emit(e)))
+      return `bf_merge ${segments.join(' ')}`
+    }
+    // The EMPTY object literal (`?? {}`) reaches here as `??`'s right
+    // operand (expression-parser.ts, `logical` case) — a RENDERED-position
+    // admission, not a value-position one. Unlike the sibling adapters, Go
     // can't silently fall back to a safe sentinel text: `this.unsupported`'s
     // `[UNSUPPORTED: …]` marker would be spliced into a Go template action
     // (e.g. as an `or`/`and` operand) and break template parsing, and the
@@ -6306,7 +6336,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // (icon registries, variant/size class maps), so this fully covers them.
     const carried = constInfo.parsed
     if (carried?.kind === 'object-literal') {
-      const hit = carried.properties.find(prop => prop.key === key)
+      // A spread entry (`{ ...t }`, #2696 Step 2) has no static key to match
+      // against — skip it, same as before this kind existed (a record const
+      // containing spread already couldn't reach here as a whole).
+      const hit = carried.properties.find(
+        (prop): prop is Extract<ObjectLiteralProperty, { kind: 'prop' }> => prop.kind === 'prop' && prop.key === key,
+      )
       if (hit && hit.value.kind === 'literal') {
         if (hit.value.literalType === 'string') return JSON.stringify(hit.value.value)
         if (hit.value.literalType === 'number') return hit.value.raw ?? String(hit.value.value)

package/src/adapter/memo/memo-compute.ts

@@ -592,6 +592,17 @@ export function memoInitialFromParsedBody(
     if (concatGo !== null) return concatGo
   }
 
+  // () => <object>.map(cb).join(sep) as the memo's WHOLE body (no `+`
+  // concatenation) — `map-object-literal-body`'s `ids` memo: `rows().map(t
+  // => ({ id: t.id, done: false })).map(r => r.id).join(',')`. The `+`-chain
+  // arm above only reaches `matchMapJoinChain` as ONE leaf of a
+  // concatenation; a bare chain memo never entered it (#2696 review).
+  const bareChain = matchMapJoinChain(body)
+  if (bareChain) {
+    const chainGo = mapJoinChainToGo(ctx, bareChain, signals, propsParams, propFallbackVars)
+    if (chainGo !== null) return chainGo
+  }
+
   return null
 }
 
@@ -954,7 +965,7 @@ export function collectPropsReadByCtorInit(
         e.elements.forEach(el => visit(el, bound))
         return
       case 'object-literal':
-        for (const p of e.properties) visit(p.value, bound)
+        for (const p of e.properties) visit(p.kind === 'spread' ? p.expr : p.value, bound)
         return
       case 'array-method':
         visit(e.object, bound)

package/src/adapter/memo/memo-value.ts

@@ -181,6 +181,9 @@ export function computeObjectMemoInitialValue(
   const env: CtorLowerEnv = { searchParamsVars: new Set(), params: new Map() }
   const entries: string[] = []
   for (const prop of retObj.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no per-key `.Params.<Field>`
+    // accessor to match against — bail, same as any other unsupported shape.
+    if (prop.kind === 'spread') return null
     // Bail on a shorthand property (`return { tag }`): its value is a bare
     // identifier whose name need not match a `.Params.<Field>` accessor.
     if (prop.shorthand) return null

package/src/adapter/memo/template-interp.ts

@@ -200,6 +200,11 @@ function recordIndexInterpolationToGo(
 
   const entries: { key: string; value: { kind: 'number' | 'string'; text: string } }[] = []
   for (const prop of parsedConst.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key/value pair this
+    // record-index lowering can bake — bail, same as any other unsupported
+    // member (a record const containing spread already couldn't reach here
+    // as a whole before this kind existed).
+    if (prop.kind === 'spread') return null
     const v = prop.value
     if (v.kind === 'literal' && v.literalType === 'number') {
       entries.push({ key: prop.key, value: { kind: 'number', text: v.raw ?? String(v.value) } })

package/src/adapter/spread/spread-codegen.ts

@@ -143,6 +143,10 @@ function parsedObjectLiteralToGoMap(parsed: ParsedExpr | undefined): string | nu
   if (!parsed || parsed.kind !== 'object-literal') return null
   const entries: string[] = []
   for (const prop of parsed.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key/value pair this
+    // conservative Go-map bake can express — bail, same as any other
+    // unsupported shape.
+    if (prop.kind === 'spread') return null
     // Reject a numeric key (`{ 1: 'a' }`); `keyKind` distinguishes it from a
     // string `'1'` key.
     if (prop.keyKind === 'numeric') return null
@@ -386,6 +390,10 @@ function objectLiteralToGoSpreadMap(
 ): string | null {
   const entries: string[] = []
   for (const prop of obj.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) isn't a per-key entry this
+    // conditional-spread inline lowering can express — bail (the docstring
+    // already declares spread out-of-scope for this function).
+    if (prop.kind === 'spread') return null
     // Shorthand (`{ describedBy }`) is unsupported.
     if (prop.shorthand) return null
     // Reject a numeric key (`{ 1: x }`); `keyKind` distinguishes it from a

package/src/adapter/value/parsed-literal-to-go.ts

@@ -63,6 +63,9 @@ function bakeInlineObjectAsGoMap(ctx: GoEmitContext, expr: ParsedExpr): string |
   if (expr.kind !== 'object-literal') return null
   const entries: string[] = []
   for (const prop of expr.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key to bake as a Go
+    // map entry — bail, same as any other unsupported shape.
+    if (prop.kind === 'spread') return null
     if (prop.shorthand) return null
     const go =
       prop.value.kind === 'object-literal'
@@ -150,6 +153,10 @@ export function parsedLiteralToGo(
     if (!structFields) return null
     const entries: string[] = []
     for (const prop of expr.properties) {
+      // A spread (`{ ...t }`, #2696 Step 2) has no static key to match a
+      // struct field against — defer the whole object, same as any other
+      // unsupported shape.
+      if (prop.kind === 'spread') return null
       // A shorthand `{ a }` carries an identifier value → lowers to null below
       // and defers the whole object.
       const goField = structFields.get(prop.key)

package/src/adapter/value/value-lowering.ts

@@ -232,6 +232,9 @@ export function objectLiteralToGoMap(ctx: GoEmitContext, expr: ParsedExpr): stri
   if (expr.kind !== 'object-literal') return null
   const entries: string[] = []
   for (const prop of expr.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key to bake as a Go
+    // map entry — bail, same as any other unsupported shape.
+    if (prop.kind === 'spread') return null
     if (prop.shorthand) return null
     const val = parsedLiteralToGo(ctx, prop.value)
     if (val === null) return null
@@ -390,40 +393,43 @@ function resolveMapJoinBaseAsGo(
   return null
 }
 
+/** `.map`/`.filter` → the runtime evaluator function that composes it. Both
+ *  take `items any` and return `[]any` (`eval.go`), so nesting one call's
+ *  result straight into another's `items` argument is exactly `.a().b()`'s
+ *  JS semantics — no expression-tree fusion needed (#2696 review). */
+const CALLBACK_EVAL_FUNC: Record<string, string> = { map: 'bf.MapEval', filter: 'bf.FilterEval' }
+
 /**
- * Lower a `.map(cb).join(sep)` chain (matched by {@link matchMapJoinChain})
- * to a `bf.Join(bf.MapEval(<items>, "<projJSON>", "<param>", <envMap>),
- * <sep>)` Go expression — the constructor-source analogue of
- * `matchFilterArmMemo`'s `bf.FilterEval` emit (`memo-compute.ts`), reusing
- * the SAME two runtime evaluator functions (`MapEval`, `eval.go`; `Join`,
- * `bf.go`) the template-position `bf_map_eval`/`bf_join` lowering already
- * calls. Shared by a memo's derived value (`memoInitialFromParsedBody`'s
- * concatenation-chain arm) and a SIGNAL's own initializer
- * (`convertInitialValue`'s `string` branch, #2492).
+ * Lower ONE `.map(cb)`/`.filter(cb)` step to a runtime-evaluator call over an
+ * already-resolved `itemsGo` Go expression: `bf.MapEval(<itemsGo>,
+ * "<projJSON>", "<param>", <envMap>)` (or `bf.FilterEval` for `.filter`).
+ * Shared by {@link resolveMapChainAsGo} (an intermediate step feeding the
+ * NEXT step's `items`) and {@link mapJoinChainToGo} (the outermost step,
+ * whose result feeds `bf.Join`).
  *
- * @returns the Go expression, or null when the receiver doesn't resolve
- *   ({@link resolveMapJoinBaseAsGo}), the projection body isn't
- *   representable to the runtime evaluator (`serializeParsedExpr` refusal),
- *   a captured free variable doesn't resolve, or the separator isn't a
- *   string literal (a dynamic separator — out of scope for this arm).
+ * @returns the Go expression, or null when the callback body isn't
+ *   representable to the runtime evaluator (`serializeParsedExpr` refusal)
+ *   or a captured free variable doesn't resolve.
  */
-export function mapJoinChainToGo(
+function callbackStepToGo(
   ctx: GoEmitContext,
-  chain: { object: ParsedExpr; arrow: Extract<ParsedExpr, { kind: 'arrow' }>; sepArg?: ParsedExpr },
+  method: string,
+  itemsGo: string,
+  arrow: Extract<ParsedExpr, { kind: 'arrow' }>,
   signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
   propsParams: { name: string; sourceName?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
 ): string | null {
-  const itemsGo = resolveMapJoinBaseAsGo(ctx, chain.object, signals, propsParams)
-  if (itemsGo === null) return null
+  const evalFunc = CALLBACK_EVAL_FUNC[method]
+  if (!evalFunc) return null
 
   const knownGetterNames = new Set(signals.map(s => s.getter))
-  const materialized = materializeGetterCalls(chain.arrow.body, knownGetterNames)
+  const materialized = materializeGetterCalls(arrow.body, knownGetterNames)
   const projJSON = serializeParsedExpr(materialized)
   if (projJSON === null) return null
 
-  const paramName = chain.arrow.params[0] ?? '_'
-  const freeVars = freeVarsInBody(materialized, new Set(chain.arrow.params))
+  const paramName = arrow.params[0] ?? '_'
+  const freeVars = freeVarsInBody(materialized, new Set(arrow.params))
   const envEntries: string[] = []
   for (const name of freeVars) {
     const sig = signals.find(s => s.getter === name)
@@ -440,6 +446,74 @@ export function mapJoinChainToGo(
   }
   const envMap = `map[string]any{${envEntries.join(', ')}}`
 
+  return `${evalFunc}(${itemsGo}, "${escapeGoString(projJSON)}", ${JSON.stringify(paramName)}, ${envMap})`
+}
+
+/**
+ * Resolve a `.map()`/`.filter()` CHAIN of any depth to a Go expression:
+ * peel off callback-method layers one at a time (`asCallbackMethodCall`),
+ * composing a `bf.MapEval`/`bf.FilterEval` call around the PREVIOUS layer's
+ * result for each one, down to the base receiver
+ * ({@link resolveMapJoinBaseAsGo} — a signal call, prop field, or array
+ * literal). `rows().map(t => ({ id: t.id, … })).map(r => r.id)` composes as
+ * `bf.MapEval(bf.MapEval(<rows>, "{id:t.id,…}", "t", {}), "r.id", "r", {})`
+ * — before this, only a chain whose FIRST layer already matched a base
+ * shape resolved; a nested map/filter layer silently fell to `null` (#2696
+ * review: `map-object-literal-body`'s two chained `.map()`s).
+ *
+ * @returns the Go expression, or null when the base receiver doesn't
+ *   resolve or any layer's callback isn't representable
+ *   ({@link callbackStepToGo}).
+ */
+function resolveMapChainAsGo(
+  ctx: GoEmitContext,
+  expr: ParsedExpr,
+  signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
+  propsParams: { name: string; sourceName?: string }[],
+  propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+): string | null {
+  const cb = asCallbackMethodCall(expr)
+  if (cb && cb.method in CALLBACK_EVAL_FUNC) {
+    const innerGo = resolveMapChainAsGo(ctx, cb.object, signals, propsParams, propFallbackVars)
+    if (innerGo === null) return null
+    return callbackStepToGo(ctx, cb.method, innerGo, cb.arrow, signals, propsParams, propFallbackVars)
+  }
+  return resolveMapJoinBaseAsGo(ctx, expr, signals, propsParams)
+}
+
+/**
+ * Lower a `.map(cb).join(sep)` chain (matched by {@link matchMapJoinChain})
+ * to a `bf.Join(<chain>, <sep>)` Go expression, where `<chain>` is the
+ * chain's OWN `.map()` step composed by {@link callbackStepToGo} over
+ * whatever {@link resolveMapChainAsGo} resolves its receiver to (a base
+ * shape, or one or more nested `.map()`/`.filter()` layers) — the
+ * constructor-source analogue of `matchFilterArmMemo`'s `bf.FilterEval`
+ * emit (`memo-compute.ts`), reusing the SAME runtime evaluator functions
+ * (`MapEval`/`FilterEval`, `eval.go`; `Join`, `bf.go`) the template-position
+ * `bf_map_eval`/`bf_join` lowering already calls. Shared by a memo's
+ * derived value (`memoInitialFromParsedBody`'s concatenation-chain arm and
+ * bare-chain arm) and a SIGNAL's own initializer (`convertInitialValue`'s
+ * `string` branch, #2492).
+ *
+ * @returns the Go expression, or null when the receiver doesn't resolve
+ *   ({@link resolveMapChainAsGo}), the projection body isn't representable
+ *   to the runtime evaluator (`serializeParsedExpr` refusal), a captured
+ *   free variable doesn't resolve, or the separator isn't a string literal
+ *   (a dynamic separator — out of scope for this arm).
+ */
+export function mapJoinChainToGo(
+  ctx: GoEmitContext,
+  chain: { object: ParsedExpr; arrow: Extract<ParsedExpr, { kind: 'arrow' }>; sepArg?: ParsedExpr },
+  signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
+  propsParams: { name: string; sourceName?: string }[],
+  propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+): string | null {
+  const itemsGo = resolveMapChainAsGo(ctx, chain.object, signals, propsParams, propFallbackVars)
+  if (itemsGo === null) return null
+
+  const mapGo = callbackStepToGo(ctx, 'map', itemsGo, chain.arrow, signals, propsParams, propFallbackVars)
+  if (mapGo === null) return null
+
   let sepGo: string
   if (!chain.sepArg) {
     sepGo = JSON.stringify(',')
@@ -449,5 +523,5 @@ export function mapJoinChainToGo(
     return null
   }
 
-  return `bf.Join(bf.MapEval(${itemsGo}, "${escapeGoString(projJSON)}", ${JSON.stringify(paramName)}, ${envMap}), ${sepGo})`
+  return `bf.Join(${mapGo}, ${sepGo})`
 }

package/src/conformance-pins.ts

@@ -52,4 +52,11 @@ export const conformancePins: ConformancePins = {
   'filter-nested-find-predicate': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2320' }],
   'date-method-uncatalogued': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2356' }],
   'rich-prop-client-read': [{ code: 'BF049', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2648' }],
+  // #2667: a ternary/array LITERALLY WRAPPING JSX at a non-children prop
+  // position (e.g. `header={cond ? <a/> : <b/>}`) is refused ahead of
+  // `adapter.generate()` in the shared jsx-to-ir.ts phase, so it is pinned
+  // identically on every adapter (including Hono) — same reasoning as
+  // `rich-prop-client-read` above.
+  'jsx-element-prop-ternary': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
+  'jsx-element-prop-array': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2667' }],
 }

package/src/render-divergences.ts

@@ -17,4 +17,9 @@
 
 import type { RenderDivergences } from '@barefootjs/jsx'
 
-export const renderDivergences: RenderDivergences = {}
+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.',
+  '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).',
+}