@barefootjs/go-template 0.17.1 → 0.18.1

package/src/adapter/lib/go-naming.ts

@@ -49,6 +49,35 @@ export function capitalizeFieldName(name: string): string {
   return name.charAt(0).toUpperCase() + name.slice(1)
 }
 
+/**
+ * Resolve ANY source property key — identifier or not (`data-priority`,
+ * `aria-label`, a numeric key) — to a valid Go struct field name. Splits on
+ * runs of characters that are invalid in a Go identifier (underscores are
+ * VALID and preserved, so a snake_case key round-trips to the exact same
+ * name `capitalizeFieldName` alone has always produced — `foo_bar` →
+ * `Foo_bar`, never `FooBar`; renaming it would break both existing member
+ * emission and consumers' hand-written constructors against generated
+ * types) and PascalCases each segment through `capitalizeFieldName`, so a
+ * hyphenated key gets a real field instead of being silently dropped
+ * (`data-priority` → `DataPriority`). A result that would start with a
+ * digit (numeric key `0`) is prefixed with `Field` (`Field0`), and a key
+ * with no usable characters at all falls back to `Field` — both keep the
+ * emitted struct compiling (not expected from real TS property names, but
+ * keeps the function total).
+ *
+ * Single source of truth for the source-key → Go-name mapping: used for
+ * struct-field generation (#2087 Phase B — `structFieldsFor`), inline-map
+ * baking (`bakeInlineObjectAsGoMap`), and the `member()` dot-access
+ * emitter, so the baked side and the accessor side can never disagree
+ * (PR #2089 review).
+ */
+export function goFieldNameForKey(key: string): string {
+  const parts = key.split(/[^A-Za-z0-9_]+/).filter(Boolean)
+  if (parts.length === 0) return 'Field'
+  const name = parts.map(capitalizeFieldName).join('')
+  return /^[0-9]/.test(name) ? `Field${name}` : name
+}
+
 /**
  * Convert a slot ID (e.g., 's6') to a Go struct field suffix (e.g., 'Slot6').
  * Keeps field names human-readable regardless of the internal slot ID format.

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

@@ -4,7 +4,11 @@
  * Free functions over a {@link GoEmitContext}. They resolve a prop/signal/const's
  * type (`TypeInfo`, a raw type string, or — as a last resort — an inferred shape
  * from a literal value) into the Go type used for its struct field. They read
- * only `state.localTypeNames`; `inferTypeFromValue` is fully pure.
+ * `state.localStructFields` / `state.localTypeAliases` (an ACTUAL Go-backed
+ * local type — a generated struct or a string-union alias) rather than the
+ * broader `state.localTypeNames` (every type definition, including a tuple
+ * alias no struct was ever emitted for — #2087); `inferTypeFromValue` is fully
+ * pure.
  */
 
 import type { TypeInfo } from '@barefootjs/jsx'
@@ -42,7 +46,19 @@ export function typeInfoToGo(
     case 'object':
       return 'map[string]interface{}'
     case 'interface':
-      if (typeInfo.raw && ctx.state.localTypeNames.has(typeInfo.raw)) {
+      // Gate on an ACTUAL backing (a generated struct — `localStructFields` —
+      // or a string-union alias — `localTypeAliases`, which emits `type X =
+      // string`), not mere presence in `localTypeNames`: the latter registers
+      // EVERY type definition unconditionally (#2087), including a tuple alias
+      // (`type Row = readonly [string, string]`) that `typeDefinitionToGo`
+      // can't turn into a struct (no object properties) and so never actually
+      // emits. Returning the bare name for one of those would reference an
+      // undeclared Go type (`[]Row`) and fail to compile — fall through to the
+      // generic-array/interface{} handling below instead, so a tuple-typed
+      // signal bakes as `[]interface{}` (each item itself an `interface{}`
+      // holding a `[]interface{}`) and the destructure `index`/`bf_slice`
+      // lowering still works via reflection regardless of the static type.
+      if (typeInfo.raw && (ctx.state.localStructFields.has(typeInfo.raw) || ctx.state.localTypeAliases.has(typeInfo.raw))) {
         return typeInfo.raw
       }
       // Resolve a raw type string pattern (e.g. `Array<Todo>`).
@@ -76,7 +92,10 @@ export function tsTypeStringToGo(ctx: GoEmitContext, tsType: string): string {
   }
   const arrayMatch = t.match(/^Array<(.+)>$/)
   if (arrayMatch) return `[]${tsTypeStringToGo(ctx, arrayMatch[1])}`
-  if (ctx.state.localTypeNames.has(t)) return t
+  // Same backing gate as `typeInfoToGo`'s 'interface' case above — an
+  // unbacked local type name (a tuple alias with no struct fields) must not
+  // be returned bare, or the generated code references an undeclared type.
+  if (ctx.state.localStructFields.has(t) || ctx.state.localTypeAliases.has(t)) return t
   return 'interface{}'
 }
 

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

@@ -3,20 +3,77 @@
  * for baking a signal's inline initial value into the SSR data context.
  *
  * Covers scalar literals, a unary-minus number, arrays of those, and object
- * literals baked against a concrete local struct.
+ * literals baked against a concrete local struct — including, per #2087, a
+ * struct property whose OWN value is a nested array or object literal
+ * (`{ id, cells: ['a', 'b'] }`, `{ id, user: { name: 'Ada' } }`): the struct's
+ * declared property TYPE (looked up from `ctx.state.currentTypeDefinitions`)
+ * threads through so a typed nested array bakes via the normal array branch
+ * below, and a nested INLINE object (one with no named Go struct —
+ * `typeInfoToGo`'s `'object'` case always falls back to
+ * `map[string]interface{}`) bakes as a capitalized-key Go map literal instead
+ * — the same convention `test-render.ts`'s harness-prop baking already uses
+ * for object elements, since `html/template`'s map field access is an exact
+ * case-sensitive `MapIndex`.
  *
  * Contract is **null-means-defer**: returns null for anything not reproduced
  * exactly — an object whose target type isn't a known struct, a key the struct
- * doesn't declare, a nested object/array property value, an empty array, an
- * identifier/call, or a numeric literal missing its `raw` token. The caller
- * then keeps `nil`.
+ * doesn't declare, an empty array, an identifier/call, or a numeric literal
+ * missing its `raw` token. The caller then keeps `nil`.
  */
 
-import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx'
+import type { ParsedExpr, TypeDefinition, TypeInfo } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
+import { goFieldNameForKey } from '../lib/go-naming.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 
+/**
+ * Look up a struct property's declared `TypeInfo` by source key, from the
+ * user's own `TypeDefinition` (not a synthesized struct — those only arise
+ * from an UNTYPED literal, which never carries nested object/array elements
+ * because `synthesizeStructFromSignal` requires every property value to be a
+ * scalar literal). Returns undefined when the struct name isn't a user type
+ * or the key isn't declared — callers treat that as "nested type unknown"
+ * and fall back to the generic/inline lowering.
+ */
+function structPropertyType(ctx: GoEmitContext, structGoType: string, key: string): TypeInfo | undefined {
+  const td = ctx.state.currentTypeDefinitions.find((t: TypeDefinition) => t.name === structGoType)
+  return td?.properties?.find(p => p.name === key)?.type
+}
+
+/**
+ * Bake a nested INLINE object-literal property value — one whose declared
+ * type has no named Go struct (`user: { name: string }` lowers its field to
+ * `map[string]interface{}`, not a struct) — as a Go map literal with
+ * CAPITALIZED keys, recursing for further nesting. `html/template`'s dot
+ * access on a map value does an exact-string `MapIndex`, so a template
+ * action like `.User.Name` only resolves when the baked key is literally
+ * `"Name"`, not the source-cased `"name"` — mirrors the same convention
+ * `test-render.ts`'s `goArrayLiteralFromArray` uses for object elements
+ * passed as harness props.
+ *
+ * Keys are sanitized with `goFieldNameForKey` — the SAME function the
+ * accessor side (`buildSegmentAccessor` / `structFieldsFor`) uses — so a
+ * non-identifier key (`'data-x'`) bakes as `"DataX"` and dot access
+ * `.Meta.DataX` finds it. `capitalizeFieldName` alone would bake
+ * `"Data-x"`, a key no emitted accessor can ever reach (Copilot review,
+ * PR #2089).
+ */
+function bakeInlineObjectAsGoMap(ctx: GoEmitContext, expr: ParsedExpr): string | null {
+  if (expr.kind !== 'object-literal') return null
+  const entries: string[] = []
+  for (const prop of expr.properties) {
+    if (prop.shorthand) return null
+    const go =
+      prop.value.kind === 'object-literal'
+        ? bakeInlineObjectAsGoMap(ctx, prop.value)
+        : parsedLiteralToGo(ctx, prop.value)
+    if (go === null) return null
+    entries.push(`${JSON.stringify(goFieldNameForKey(prop.key))}: ${go}`)
+  }
+  return `map[string]interface{}{${entries.join(', ')}}`
+}
+
 export function parsedLiteralToGo(
   ctx: GoEmitContext,
   expr: ParsedExpr,
@@ -79,10 +136,26 @@ export function parsedLiteralToGo(
       // and defers the whole object.
       const goField = structFields.get(prop.key)
       if (!goField) return null
-      // Nested object/array property values aren't baked here (field types
-      // untracked) — defer.
-      if (prop.value.kind === 'object-literal' || prop.value.kind === 'array-literal') return null
-      const go = parsedLiteralToGo(ctx, prop.value)
+      const propType = structPropertyType(ctx, goType, prop.key)
+      let go: string | null
+      if (prop.value.kind === 'array-literal') {
+        // A nested array property (`cells: readonly string[]`, #2087):
+        // thread the struct's own declared property type through so the
+        // array branch below bakes a properly-typed slice (`[]string{…}`)
+        // instead of deferring.
+        go = parsedLiteralToGo(ctx, prop.value, propType)
+      } else if (prop.value.kind === 'object-literal') {
+        // A nested object property (`user: { name: string }`, #2087): bake
+        // against a named struct if the declared type resolves to one,
+        // else fall back to the capitalized-key inline-map convention.
+        const nestedGoType = propType ? typeInfoToGo(ctx, propType) : undefined
+        go =
+          nestedGoType && ctx.state.localStructFields.has(nestedGoType)
+            ? parsedLiteralToGo(ctx, prop.value, propType)
+            : bakeInlineObjectAsGoMap(ctx, prop.value)
+      } else {
+        go = parsedLiteralToGo(ctx, prop.value)
+      }
       if (go === null) return null
       entries.push(`${goField}: ${go}`)
     }

package/src/conformance-pins.ts

@@ -0,0 +1,135 @@
+/**
+ * Per-fixture build-time contracts for shapes the Go template adapter
+ * intentionally refuses to lower. Lives here (not on the shared fixtures)
+ * so adding a new adapter doesn't require touching any cross-adapter
+ * file — every adapter declares its own refusal set against the
+ * canonical fixture corpus. Consumed by this package's own conformance
+ * test (as `expectedDiagnostics`) and by `bf compat` (issue-URL
+ * attribution).
+ */
+
+import type { ConformancePins } from '@barefootjs/jsx'
+
+export const conformancePins: ConformancePins = {
+  // `style-object-dynamic` / `style-3-signals` no longer pinned — a
+  // `style={{ … }}` object literal now lowers to a CSS string with dynamic
+  // values interpolated (`background-color:{{.Color}};padding:8px`) via
+  // `tryLowerStyleObject` (#1322).
+  // Sibling-imported child component inside a loop body: the adapter
+  // emits `{{template "X" .}}` which only resolves if the user has
+  // compiled the sibling file and registered the template on the
+  // same instance. BF103 makes that requirement loud. (The barefoot
+  // CLI passes `siblingTemplatesRegistered: true` so CLI builds
+  // suppress the diagnostic — see compileJSX `siblingTemplatesRegistered`.)
+  'static-array-children': [{ code: 'BF103', severity: 'error' }],
+  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
+  // call it inside a keyed `.map`. Same BF103 surface as
+  // `static-array-children` above — pinned at adapter level so the
+  // shared-component corpus stays adapter-neutral.
+  'todo-app': [{ code: 'BF103', severity: 'error' }],
+  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // `([emoji, users]) => ...` is an array-index tuple destructure — #2087
+  // Phase B's widened gate now admits this shape (`destructure-array-index-in-map`
+  // exercises the same `segments`-based lowering). The remaining refusal here
+  // is orthogonal: `entries` is a function-scope local const with a computed
+  // initializer (`Object.entries(props.reactions ?? {}).filter(...)`) that
+  // the Go adapter has no binding for (only a STRING-derived local resolves
+  // to a generated struct field, via `computeDerivedConstFields`/`isStringExpr`)
+  // — left unchecked this would silently execute-time-fail instead of
+  // building loud, so `renderLoop` raises BF101 for a bare-identifier loop
+  // array bound to such a const. See the `renderLoop` comment at the check
+  // site; Jinja / ERB apply the same narrow check for the same reason.
+  'static-array-from-props': [{ code: 'BF101', severity: 'error' }],
+  // Same computed-const array as above, plus the pre-existing BF103 (a
+  // sibling-imported child component used inside the loop body) — the
+  // destructure param itself no longer contributes a diagnostic.
+  'static-array-from-props-with-component': [
+    { code: 'BF103', severity: 'error' },
+    { code: 'BF101', severity: 'error' },
+  ],
+  // (`style-3-signals` graduated alongside `style-object-dynamic` — see note
+  // above; the `style={{ … }}` object now lowers to a CSS string.)
+  // (`tagged-template-classname` graduated by #2092 — the tag resolves
+  // through the interleave-tag catalogue and desugars to an untagged
+  // template literal, so it lowers like any other className template.)
+  // #2038: a filter predicate whose body contains a NESTED callback call
+  // (`t => !picked().some(p => …)` / `t => picked().find(p => …)`). The
+  // evaluator refuses nested arrows and `renderFilterExpr` has no faithful
+  // Go form for the inner call (its `call` arm used to silently drop the
+  // arrow argument and render only the callee) — the compiler is loud
+  // instead of lossy. The `/* @client */` twin
+  // (`filter-nested-callback-predicate-client`) has no pin here: it must
+  // render clean on every adapter, which asserts the suppression contract.
+  // https://github.com/piconic-ai/barefootjs/issues/2038
+  'filter-nested-callback-predicate': [
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2038' },
+  ],
+  'filter-nested-find-predicate': [
+    { code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2038' },
+  ],
+  // #1310 / #2087: rest destructure in .map() callback. `isLowerableLoopDestructure`
+  // now admits every shape this fixture family exercises — each fixed/rest
+  // binding resolves via `buildSegmentAccessor`/`buildDestructureBindingMap`
+  // against a synthetic `$__bf_item0` range var (the reserved `__bf_item`
+  // name, depth-suffixed): a plain field → `$__bf_item0.Id`, an array-index
+  // step → `(index $__bf_item0 0)`, an array-rest → `(bf_slice $__bf_item0
+  // 1)` (composes under `.length` via `member()`'s generic `len <obj>` arm),
+  // and an object-rest member read (`rest.flag`) → `$__bf_item0.Flag`. A
+  // `{...rest}` SPREAD (`rest-destructure-object-spread-in-map`) routes
+  // through the new `bf_omit` runtime helper instead, so the residual omits
+  // exactly the sibling keys the pattern destructured out. No fixture in
+  // this family is pinned anymore — all six render to real Go / byte-exact
+  // HTML (`rest-destructure-object-in-map`, `rest-destructure-object-spread-in-map`,
+  // `rest-destructure-array-in-map`, `rest-destructure-nested-in-map`,
+  // `destructure-array-index-in-map`, `destructure-nested-object-in-map`).
+  // #1443: `[a, b].filter(Boolean).join(' ')` (registry Slot) now
+  // lowers to `bf_join (bf_filter_truthy (bf_arr ...)) " "`. No
+  // BF101 expected — pinned positively by the
+  // `branch-local-filter-join-go` template-output test below.
+  //
+  // #1448 Tier A — JS Array / String methods that the Go template
+  // adapter hasn't lowered yet. Each row drops once the
+  // corresponding method PR lands. Hono / CSR pass these out of
+  // the box (they evaluate JS at runtime) so the pin only applies
+  // here.
+  //
+  // `array-includes` / `string-includes` no longer pinned — both
+  // shapes lower via the shared `array-method` IR + the polymorphic
+  // `bf_includes` runtime helper that dispatches on
+  // `reflect.Kind()` (slice/array → element search, string →
+  // substring search). The condition-position lowering picks up
+  // the same emit through the `array-method` arm of
+  // `renderConditionExpr` (#1448 Tier A first PR).
+  //
+  // Remaining fixtures land at expression position and surface BF101
+  // via `convertExpressionToGo`. Distinct codes for the two paths is
+  // pre-existing adapter behaviour, not something this catalog
+  // should paper over — pinned literally here.
+  // `array-indexOf` / `array-lastIndexOf` no longer pinned —
+  // value-equality `bf_index_of` / `bf_last_index_of` Go runtime
+  // helpers handle the shape (#1448 Tier A second PR).
+  // `array-at` no longer pinned — the pre-existing `bf_at` runtime
+  // helper now lowers `.at(i)` (#1448 Tier A third PR).
+  // `array-concat` no longer pinned — the new `bf_concat` runtime
+  // helper merges two arrays into a single `[]any` (#1448 Tier A
+  // fourth PR).
+  // `array-slice` no longer pinned — the new `bf_slice` runtime
+  // helper carves out a sub-range with JS-compat clamping
+  // (#1448 Tier A fifth PR).
+  // `array-reverse` / `array-toReversed` no longer pinned —
+  // both share the `bf_reverse` helper since SSR templates
+  // render a snapshot and the JS mutate-vs-new distinction has
+  // no template-level meaning (#1448 Tier A sixth PR).
+  // `string-toLowerCase` / `string-toUpperCase` no longer pinned —
+  // pre-existing `bf_lower` / `bf_upper` runtime helpers wire to
+  // the JS method names at the adapter layer (#1448 Tier A
+  // seventh + eighth PRs).
+  // `string-trim` no longer pinned — pre-existing `bf_trim`
+  // (wraps `strings.TrimSpace`) handles the strip (#1448 Tier A
+  // ninth PR, closing out Tier A).
+  // #2073 follow-up: a function-reference `.map(format)` callback has no
+  // arrow body to serialize — not a CALLBACK_METHODS shape — so the
+  // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
+  // a broken template.
+  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
+}

package/src/index.ts

@@ -6,3 +6,4 @@
 
 export { GoTemplateAdapter, goTemplateAdapter } from './adapter/index.ts'
 export type { GoTemplateAdapterOptions } from './adapter/index.ts'
+export { conformancePins } from './conformance-pins.ts'