@barefootjs/go-template 0.31.8 → 0.31.10

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

@@ -944,7 +944,8 @@ export function List() {
       // A struct is synthesised with one field per inferred key + Go type.
       expect(types).toMatch(/type \w+ struct \{[\s\S]*ID string[\s\S]*N int[\s\S]*Ok bool[\s\S]*\}/)
       // The signal field is a slice of the synthesised struct, not []interface{}.
-      expect(types).toMatch(/Items \[\]\w+ `json:"items"`/)
+      // Excluded from bf-p (json:"-") — component-internal signal state (#2672).
+      expect(types).toMatch(/Items \[\]\w+ `json:"-"`/)
       expect(types).not.toContain('Items []interface{}')
       // The initial items are baked, not nil.
       expect(types).not.toContain('Items: nil,')
@@ -1092,15 +1093,18 @@ export function Rows() {
       expect(types).toContain('Rows: []Row{Row{DataID: "a"}},')
     })
 
-    test('bakes a non-Go-identifier key inside a nested INLINE object with the same sanitizer as the accessor side (#2089 review)', () => {
-      // A nested inline-object property (`meta: { 'data-x': string }` — no
-      // named Go struct, lowered to map[string]interface{}) bakes as a Go map
-      // literal. The map KEY must be produced by `goFieldNameForKey` — the
-      // same function `buildSegmentAccessor`/`structFieldsFor` use — so the
-      // emitted accessor (`.Meta.DataX`, an exact-string MapIndex on maps)
-      // actually finds the value. `capitalizeFieldName` alone would bake
-      // `"Data-x"`, a key no emitted accessor can reach, silently rendering
-      // empty (flagged by Copilot on PR #2089).
+    test('bakes a non-Go-identifier key inside a nested INLINE object via the sanitizer-named synthesized struct (#2089 review, superseded by #2674)', () => {
+      // A nested inline-object property (`meta: { 'data-x': string }`) used
+      // to have no named Go struct and lower to `map[string]interface{}`,
+      // baked as a Go map literal with a `goFieldNameForKey`-sanitized key
+      // (`"DataX"`, not the invalid-accessor `"Data-x"` — #2089). #2674's
+      // struct-synthesis pre-pass now gives it a real struct (`RowMeta`)
+      // instead — the FIELD name still comes from the same sanitizer
+      // (`goFieldNameForKey`), so the accessor (`.Meta.DataX`) and the json
+      // tag (the ORIGINAL unsanitized source key, `"data-x"` — the struct
+      // field's json tag, not the map-baking convention's capitalized key)
+      // both still resolve correctly; only the container changed from a map
+      // to a struct.
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`
 "use client"
@@ -1113,8 +1117,11 @@ export function Rows() {
 }
 `)
       const types = adapter.generate(ir).types!
-      expect(types).toContain('map[string]interface{}{"DataX": "v"}')
+      expect(types).toContain('type RowMeta struct {')
+      expect(types).toContain('DataX string `json:"data-x"`')
       expect(types).not.toContain('"Data-x"')
+      expect(types).toContain('Row{ID: "r1", Meta: RowMeta{DataX: "v"}}')
+      expect(types).not.toContain('map[string]interface{}')
     })
 
     test('snake_case keys keep their underscore in the generated field name (#2089 review)', () => {
@@ -1692,6 +1699,56 @@ export function Box({ children }: { children: any }) {
       const types = adapter.generateTypes(ir)!
       expect(types).toMatch(/Children\s+\S+\s+`json:"-"`/)
     })
+
+    test('signal and memo fields are excluded from bf-p serialization — user props only (#2672)', () => {
+      // A signal-bearing component whose only DECLARED prop is `label`, plus
+      // a signal (`count`, not itself a prop) and a memo derived from it
+      // (`doubled`). Only `label` may carry a real json tag — `count` and
+      // `doubled` are component-internal state/derivation the client
+      // re-derives itself and never reads back off `_p`.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+'use client'
+import { createSignal, createMemo } from '@barefootjs/client'
+export function Counter(props: { label: string }) {
+  const [count, setCount] = createSignal(0)
+  const doubled = createMemo(() => count() * 2)
+  return <button onClick={() => setCount(count() + 1)}>{props.label}: {count()} / {doubled()}</button>
+}
+`, adapter)
+      const types = adapter.generateTypes(ir)!
+      // The real prop keeps its real tag — hydration reads `_p.label`.
+      expect(types).toMatch(/Label\s+\S+\s+`json:"label"`/)
+      // The signal field is component-internal state, not caller input.
+      expect(types).toMatch(/Count\s+\S+\s+`json:"-"`/)
+      // The memo field is component-internal derivation, not caller input.
+      expect(types).toMatch(/Doubled\s+\S+\s+`json:"-"`/)
+    })
+
+    test('prop-backed signal default still keeps the PROP field a real tag (#2672)', () => {
+      // Mirrors the `signal-default-from-jsx` adapter-tests fixture: `x` is a
+      // declared PROP whose default happens to come from a signal initial
+      // value (keeps a real tag, seeds client-side `createSignal(_p.x ?? 7)`),
+      // while `incremented` is a pure memo derivation the client never reads
+      // off `_p`. Flipping signal/memo fields to `json:"-"` must NOT touch
+      // this prop field — it is the loop-guard case CLAUDE.md's "don't flip
+      // prop-backed fields" warns against.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+'use client'
+import { createSignal, createMemo } from '@barefootjs/client'
+export function SignalDefaultFromJsx(props: { x?: number }) {
+  const [x, setX] = createSignal(props.x ?? 7)
+  const incremented = createMemo(() => x() + 1)
+  return <div onClick={() => setX(x() + 1)}>{x()} / {incremented()}</div>
+}
+`, adapter)
+      const types = adapter.generateTypes(ir)!
+      // The prop-backed field keeps its real tag — hydration reads `_p.x`.
+      expect(types).toMatch(/X\s+\S+\s+`json:"x"`/)
+      // The memo field is component-internal derivation, not caller input.
+      expect(types).toMatch(/Incremented\s+\S+\s+`json:"-"`/)
+    })
   })
 
   describe('generateTypes', () => {
@@ -4854,6 +4911,39 @@ export function Counter({ count: initialCount }: { count: number }) {
     expect((types.match(/json:"count"/g) ?? []).length).toBe(1)
   })
 
+  // #2672 near-miss: a prop-derived dynamic loop's nested-array field is
+  // normally redundant (the client re-derives every row from the real prop
+  // field, e.g. `_p.items`) and gets `json:"-"`. But when the array field's
+  // Go name collides with its OWN driving prop's Go name — `toggleItems`
+  // driving a `.map()` into `<ToggleItem>` both capitalize to `ToggleItems`
+  // — `emitPropsDataFields` already shadows the prop's own field to avoid a
+  // Go redeclaration, so the nested-array field is the ONLY struct field
+  // carrying that prop's data. Flipping it to `-` there would silently drop
+  // caller input from `bf-p` instead of trimming a redundant copy. Caught by
+  // the `hydration-props-inventory` oracle against the `toggle-shared`
+  // fixture (a real `integrations/shared/components/Toggle.tsx` shape)
+  // before landing; this pins the same shape directly.
+  test('a prop-derived nested-array field keeps a real tag when it shadows its own driving prop (#2672)', () => {
+    const result = compileJSX(`
+type ToggleItemProps = { label: string; defaultOn?: boolean }
+function ToggleItem(props: ToggleItemProps) {
+  return <div>{props.label}</div>
+}
+type ToggleProps = { toggleItems: ToggleItemProps[] }
+export function Toggle({ toggleItems }: ToggleProps) {
+  return <div>{toggleItems.map((item) => <ToggleItem key={item.label} label={item.label} defaultOn={item.defaultOn} />)}</div>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const types = result.files.find(f => f.type === 'types')!.content
+    const togglePropsAndAfter = types.slice(types.indexOf('type ToggleProps struct'))
+    // The shadowed scalar prop field is absent...
+    expect(togglePropsAndAfter.slice(0, togglePropsAndAfter.indexOf('}'))).not.toMatch(/\bItems\b/)
+    // ...and the nested-array field is the sole carrier, with a REAL tag —
+    // not `json:"-"`, which would drop `toggleItems` from `bf-p` entirely.
+    expect((togglePropsAndAfter.match(/json:"toggleItems"/g) ?? []).length).toBe(1)
+  })
+
   // The nested-array skip check must union both namings at all four sites
   // (`isNestedArrayShadowed`) — a one-sided check lets Input and
   // Props/NewProps disagree on whether an aliased prop's field exists.
@@ -5029,11 +5119,14 @@ export function TodoItem(props: Props) {
     // field Done in type TodoItemProps`) or — since `bf_sort_eval`-style
     // evaluators are untouched by this fix, only the html/template dot-path
     // is — renders wrong. Post-fix: only the not-done todo (id 2) survives
-    // the 'active' filter.
-    expect(html).not.toContain('Eat breakfast')
-    expect(html).toContain('Write tests')
-    expect(html).toContain('data-key="2"')
-    expect(html).not.toContain('data-key="1"')
+    // the 'active' filter. The bf-p hydration payload legitimately carries
+    // the full unfiltered `initialTodos` (both quote styles, mirroring
+    // `normalizeHTML`), so the assertions target the rendered list only.
+    const rendered = html.replace(/\s*bf-p=(?:"[^"]*"|'[^']*')/g, '')
+    expect(rendered).not.toContain('Eat breakfast')
+    expect(rendered).toContain('Write tests')
+    expect(rendered).toContain('data-key="2"')
+    expect(rendered).not.toContain('data-key="1"')
   })
 })
 
@@ -5909,3 +6002,170 @@ export function Counter() {
     expect(template).not.toContain('<link')
   })
 })
+
+describe('GoTemplateAdapter - #2674 anonymous object types synthesize named structs', () => {
+  // Plan A: a type with no name — an inline array-element type or a nested
+  // anonymous property inside a named type — used to lower to
+  // `map[string]interface{}` with DELIBERATELY PascalCased keys
+  // (`bakeInlineObjectAsGoMap`, #2087/#1487: `html/template`'s dot access on
+  // a map does an exact-string `MapIndex`). SSR rendered fine off that
+  // convention, but `BfPropsAttr`'s `json.Marshal` ships the SAME map, so
+  // the hydration payload leaked Go casing (`{"Name":"Ada"}` instead of
+  // `{"name":"Ada"}`). `emitSynthPropStructs` now synthesizes a
+  // deterministically-named, json-tagged struct for these types instead, so
+  // the SAME value bakes as a typed struct literal and `json.Marshal`
+  // produces the correct camelCase payload without changing SSR at all.
+
+  test('inline array-element type synthesizes a named json-tagged struct (case i)', () => {
+    // `items: { id: number; tags: string[] }[]` has no backing
+    // `TypeDefinition` at all — only `ir.metadata.propsParams`' own
+    // `TypeInfo` tree carries its shape.
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  return <ul>{props.items.map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+export { TaggedList }
+`)
+    const types = adapter.generateTypes(ir)!
+    expect(types).toContain('type TaggedListItemsItem struct {')
+    expect(types).toContain('Title string `json:"title"`')
+    expect(types).toContain('Tags []string `json:"tags"`')
+    // The Input/Props field is a typed struct slice, not the old
+    // `[]map[string]interface{}` fallback.
+    expect(types).toMatch(/Items \[\]TaggedListItemsItem/)
+    expect(types).not.toContain('map[string]interface{}')
+  })
+
+  test('nested anonymous property inside a NAMED type synthesizes a named struct (case ii, Row.user)', () => {
+    // `Row` is a real `TypeDefinition`; its `user` property has no name of
+    // its own — only `ir.metadata.typeDefinitions` carries `Row`'s property
+    // list (a `{kind:'interface', raw:'Row'}` prop reference does not).
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Row = { id: string; user: { name: string } }
+export function NestedNames() {
+  const [rows, setRows] = createSignal<Row[]>([
+    { id: "r1", user: { name: "Ada" } },
+    { id: "r2", user: { name: "Grace" } },
+  ])
+  return (
+    <ul onClick={() => setRows((r) => r)}>
+      {rows().map(({ id, user: { name } }) => (
+        <li key={id}>{name}</li>
+      ))}
+    </ul>
+  )
+}
+`)
+    const types = adapter.generateTypes(ir)!
+    expect(types).toContain('type RowUser struct {')
+    expect(types).toContain('Name string `json:"name"`')
+    expect(types).toContain('User RowUser `json:"user"`')
+    // The signal's inline initial value bakes through the STRUCT literal
+    // path, not `bakeInlineObjectAsGoMap`'s capitalized-key map convention.
+    expect(types).toContain('Row{ID: "r1", User: RowUser{Name: "Ada"}}')
+    expect(types).not.toContain('map[string]interface{}')
+  })
+
+  test('a synthesized-name collision gracefully falls back to the pre-#2674 map convention, not a regression', () => {
+    // `synthesizeStructFromSignal`'s existing collision precedent
+    // (#1680, `keeps nil when the synthesised name collides with a user
+    // type`), mirrored for `emitSynthPropStructs`: when the deterministic
+    // name (`Row><Prop>`) is already taken by a real user type, synthesis
+    // is declined for that ONE type and it keeps the historical map
+    // fallback — SSR stays correct (`bakeInlineObjectAsGoMap` still bakes
+    // it), only the hydration-payload casing fix doesn't apply to it.
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type RowUser = { handle: string }
+type Row = { id: string; user: { name: string } }
+export function NestedNames() {
+  const [rows] = createSignal<Row[]>([{ id: "r1", user: { name: "Ada" } }])
+  return <ul>{rows().map(({ id, user: { name } }) => <li key={id}>{name}</li>)}</ul>
+}
+`)
+    const types = adapter.generateTypes(ir)!
+    // The user's own `RowUser` struct is emitted, untouched...
+    expect(types).toContain('type RowUser struct {')
+    expect(types).toContain('Handle string `json:"handle"`')
+    // ...and `Row.user` — whose synthesized name collides with it — falls
+    // back to the map convention rather than being silently mistyped as
+    // the unrelated user type.
+    expect(types).toMatch(/User map\[string\]interface\{\}/)
+    expect(types).toContain('map[string]interface{}{"Name": "Ada"}')
+  })
+
+  test('real go-run render: bf-p carries camelCase keys for an inline array-element prop (case i)', async () => {
+    const source = `
+function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  return <ul>{props.items.map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+export { TaggedList }
+`
+    let html: string
+    try {
+      html = await renderGoTemplateComponent({
+        source,
+        adapter: new GoTemplateAdapter(),
+        props: { items: [{ title: 'Alpha', tags: ['a', 'b'] }] },
+      })
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) return // Go toolchain not installed on this host
+      throw err
+    }
+    const bfPMatch = html.match(/bf-p="([^"]*)"/)
+    expect(bfPMatch).not.toBeNull()
+    const decoded = bfPMatch![1]
+      .replace(/&#34;/g, '"')
+      .replace(/&quot;/g, '"')
+    const payload = JSON.parse(decoded)
+    expect(payload).toEqual({ items: [{ title: 'Alpha', tags: ['a', 'b'] }] })
+  })
+
+  test('real go-run render: a signal-backed nested anonymous object is baked into SSR HTML but excluded from bf-p (#2672)', async () => {
+    // `rows` here is a SIGNAL, not a prop — `NestedNames` takes no props at
+    // all. Its data still resolves the synthesized-struct-type branch of
+    // `emitPropsDataFields` (the case ii struct-synthesis this describe
+    // block exists to cover), so this doubles as a real-go-run confirmation
+    // that branch's json tag is also `-` now, not just the general one.
+    // `{{.Field}}` SSR access is unaffected by json tags — the rendered
+    // `<li>Ada</li>` still bakes correctly; only `bf-p` (component-internal
+    // signal state, not caller input) drops the redundant `rows` key.
+    const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Row = { id: string; user: { name: string } }
+export function NestedNames() {
+  const [rows] = createSignal<Row[]>([{ id: "r1", user: { name: "Ada" } }])
+  return <ul>{rows().map(({ id, user: { name } }) => <li key={id}>{name}</li>)}</ul>
+}
+`
+    let html: string
+    try {
+      html = await renderGoTemplateComponent({ source, adapter: new GoTemplateAdapter() })
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) return // Go toolchain not installed on this host
+      throw err
+    }
+    // SSR HTML still bakes the signal's initial data — unaffected by the
+    // json tag, since `{{.Field}}` template access doesn't consult it.
+    expect(html).toContain('<li')
+    expect(html).toContain('Ada')
+    const bfPMatch = html.match(/bf-p="([^"]*)"/)
+    expect(bfPMatch).not.toBeNull()
+    const decoded = bfPMatch![1]
+      .replace(/&#34;/g, '"')
+      .replace(/&quot;/g, '"')
+    const payload = JSON.parse(decoded)
+    // No props at all on this component — bf-p carries nothing.
+    expect(payload).toEqual({})
+  })
+})