@barefootjs/go-template 0.7.0 → 0.9.0

package/dist/test-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,iBAAiB,CAAA;AAOnE,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAgCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,eAAe,CAAA;IACxB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAmNvF"}
+{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,iBAAiB,CAAA;AAOnE,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAgCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,eAAe,CAAA;IACxB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAsRvF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,6 +54,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.7.0"
+    "@barefootjs/jsx": "0.9.0"
   }
 }

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

@@ -35,17 +35,6 @@ runAdapterConformanceTests({
   // `BF104` at build time instead of silently emitting invalid
   // template syntax (#1266).
   skipJsx: [
-    'return-map',
-    // #1297 fixed the harness-side IR emission gate (multi-component
-    // sources now emit one `ir` file per component, and the harness
-    // picks the entry-point IR). The remaining gap is adapter-side:
-    // the go-template adapter has no SSR context-propagation
-    // mechanism, so `<Ctx.Provider value="dark">` doesn't make
-    // `useContext(Ctx)` resolve to `"dark"` at template-eval time —
-    // the template emits `.Theme` against a struct that has no
-    // `Theme` field. Provider SSR coverage on go-template waits on
-    // that adapter feature; see #1297 follow-up.
-    'context-provider',
     // #1244 stress catalog (#1326): `children={<span/>}` — the IR
     // hoists the span with `needsScope: true` so the Hono reference
     // emits `bf-s` on the inner `<span>`. The Go adapter renders the
@@ -76,17 +65,6 @@ runAdapterConformanceTests({
     // option fixed on the Hono side. Separate follow-up.
     'toggle-shared',
     'props-reactivity-comparison',
-    // #1467 Phase 2b: basic interactive `site/ui` primitives. Cross-adapter
-    // parity for the `site/ui` corpus is Phase 3, so these participate only
-    // in Hono SSR conformance + the fixture-hydrate runtime layer for now.
-    // (`label` and `kbd` are static helpers; `toggle` / `switch` /
-    // `checkbox` carry uncontrolled state; `input` / `textarea` are
-    // pass-through native controls.)
-    'toggle',
-    'switch',
-    'checkbox',
-    'textarea',
-    'kbd',
   ],
   // Per-fixture build-time contracts for shapes the Go template
   // adapter intentionally refuses to lower. Lives here (not on the
@@ -818,6 +796,279 @@ export function List() {
     })
   })
 
+  describe('conditional inline-object spread (textarea aria-describedby)', () => {
+    // `{...(cond ? { 'aria-describedby': cond } : {})}` lowers to an
+    // IIFE-of-maps in `NewXxxProps` so the falsy branch OMITS the key
+    // (SpreadAttrs does not filter empty strings). The fixture only
+    // exercises the falsy branch; this pins the TRUTHY branch.
+    test('lowers to a conditional map IIFE and keeps the {{bf_spread_attrs}} template', () => {
+      const source = `
+function Box({ describedBy }: { describedBy?: string }) {
+  return <div {...(describedBy ? { 'aria-describedby': describedBy } : {})} />
+}
+`
+      const { template, types } = compileAndGenerate(source)
+      // Template emission is unchanged from the proven {...props} path.
+      expect(template).toContain('{{bf_spread_attrs .Spread_0}}')
+      // The bag value is a conditional map built in NewBoxProps. The
+      // prop type is unresolved (interface{}), so the condition routes
+      // through `bf.Truthy` for a faithful JS `Boolean(x)` test.
+      expect(types).toContain('Spread_0: func() map[string]any {')
+      expect(types).toContain('if bf.Truthy(in.DescribedBy) {')
+      expect(types).toContain('return map[string]any{"aria-describedby": in.DescribedBy}')
+      expect(types).toContain('return map[string]any{}')
+    })
+
+    test('resolves the object value reference and key for a second prop', () => {
+      const source = `
+function Box({ label }: { label: string }) {
+  return <div {...(label ? { 'data-label': label } : {})} />
+}
+`
+      const { types } = compileAndGenerate(source)
+      // The condition prop and the value reference resolve to `in.<Field>`,
+      // the static key is preserved. (The analyzer surfaces these
+      // destructured props as `unknown`/`interface{}`, so the condition
+      // routes through `bf.Truthy` for a faithful JS truthiness test.)
+      expect(types).toContain('if bf.Truthy(in.Label) {')
+      expect(types).toContain('return map[string]any{"data-label": in.Label}')
+    })
+
+    test('refuses a non-identifier condition with BF101 (out-of-shape fallback)', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+function Box({ a, b }: { a?: string; b?: string }) {
+  return <div {...(a === b ? { 'data-x': a } : {})} />
+}
+`
+      const ir = compileToIR(source, adapter)
+      adapter.generate(ir)
+      const errs = (adapter as unknown as { errors: { code: string }[] }).errors
+      expect(errs.some(e => e.code === 'BF101')).toBe(true)
+    })
+  })
+
+  describe('local-const conditional-spread resolution (#checkbox icon)', () => {
+    // A FUNCTION-scope const holding a `cond ? {…} : {}` ternary, then
+    // spread as a bare identifier (`{...sizeAttrs}`), resolves through the
+    // same conditional-spread lowering as the inline form. CheckIcon's
+    // `const sizeAttrs = size ? {…} : {}` is exactly this shape.
+    test('resolves a bare-identifier spread of a function-scope conditional const', () => {
+      const source = `
+function Box({ flag }: { flag?: boolean }) {
+  const attrs = flag ? { 'data-on': 'yes' } : {}
+  return <div {...attrs} />
+}
+`
+      const { template, types } = compileAndGenerate(source)
+      expect(template).toContain('{{bf_spread_attrs .Spread_0}}')
+      expect(types).toContain('Spread_0: func() map[string]any {')
+      expect(types).toContain('return map[string]any{"data-on": "yes"}')
+      expect(types).toContain('return map[string]any{}')
+    })
+
+    // A const that resolves to another bare identifier must NOT be
+    // forwarded (loop guard) — it falls through to BF101 like any other
+    // unsupported spread identifier.
+    test('does not forward a const that aliases another identifier (loop guard)', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+function Box({ other }: { other?: object }) {
+  const attrs = other
+  return <div {...attrs} />
+}
+`
+      const ir = compileToIR(source, adapter)
+      adapter.generate(ir)
+      const errs = (adapter as unknown as { errors: { code: string }[] }).errors
+      expect(errs.some(e => e.code === 'BF101')).toBe(true)
+    })
+  })
+
+  describe('Record<staticKeys,scalar>[propKey] spread value (#checkbox icon)', () => {
+    // `const sizeMap: Record<IconSize, number> = { sm: 16, ... }` indexed
+    // by a prop inside a conditional-spread object value lowers to an
+    // inline indexed Go map keyed via `fmt.Sprint(in.<Field>)`. This is
+    // CheckIcon's `{ width: sizeMap[size], height: sizeMap[size] }` shape.
+    test('lowers an indexed module-const map to an inline fmt.Sprint-keyed map and adds the fmt import', () => {
+      const source = `
+const sizeMap: Record<string, number> = { sm: 16, md: 20, lg: 24, xl: 32 }
+function Box({ size }: { size?: string }) {
+  const attrs = size ? { width: sizeMap[size] } : {}
+  return <div {...attrs} />
+}
+`
+      const { types } = compileAndGenerate(source)
+      expect(types).toContain(
+        'map[string]any{"sm": 16, "md": 20, "lg": 24, "xl": 32}[fmt.Sprint(in.Size)]',
+      )
+      // The `"fmt"` import is emitted only when this lowering fires.
+      expect(types).toContain('\t"fmt"')
+    })
+
+    test('lowers string-valued record maps too', () => {
+      const source = `
+const labelMap: Record<string, string> = { a: 'Alpha', b: 'Beta' }
+function Box({ k }: { k?: string }) {
+  const attrs = k ? { 'data-label': labelMap[k] } : {}
+  return <div {...attrs} />
+}
+`
+      const { types } = compileAndGenerate(source)
+      expect(types).toContain('map[string]any{"a": "Alpha", "b": "Beta"}[fmt.Sprint(in.K)]')
+    })
+
+    // A non-scalar record value (object / array / call) is out of shape:
+    // the spread object value can't lower, so the whole spread falls back
+    // to BF101 rather than emitting an invalid map.
+    test('refuses a non-scalar record value with BF101 (out-of-shape fallback)', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+const sizeMap: Record<string, object> = { sm: { w: 1 } }
+function Box({ size }: { size?: string }) {
+  const attrs = size ? { width: sizeMap[size] } : {}
+  return <div {...attrs} />
+}
+`
+      const ir = compileToIR(source, adapter)
+      adapter.generate(ir)
+      const errs = (adapter as unknown as { errors: { code: string }[] }).errors
+      expect(errs.some(e => e.code === 'BF101')).toBe(true)
+    })
+  })
+
+  describe('props-object inherited-attribute enumeration (#checkbox)', () => {
+    // A SolidJS props-object component (`function C(props: P)`) that reads
+    // inherited attributes (`props.className` in a memo, `props.id` /
+    // `props.disabled` on the root) must expose Input/Props fields for them,
+    // even though `propsParams` only enumerates `P`'s own members. Without
+    // this the caller's `className: ''` has no field — `unknown field
+    // ClassName in struct literal of type CInput`.
+    test('reads of props.className / props.id / props.disabled become Input fields', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createMemo } from "@barefootjs/client"
+interface P { tone?: string }
+export function Widget(props: P) {
+  const classes = createMemo(() => \`base \${props.className ?? ''}\`)
+  return <button id={props.id} disabled={props.disabled ?? false} class={classes()}>x</button>
+}
+`
+      const ir = compileToIR(source, adapter)
+      const types = adapter.generateTypes(ir)!
+      expect(types).toContain('ClassName string')
+      // `id` is a bare-reference optional → interface{} (nillable, omittable).
+      expect(types).toContain('ID interface{}')
+      expect(types).toContain('Disabled bool')
+    })
+
+    // The className memo's SSR initial value must inline module string consts
+    // (incl. `[...].join(' ')`) and resolve `props.className ?? ''` to the
+    // ClassName field — not render the historical `0` placeholder.
+    test('template-literal className memo inlines consts + props.className field', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createMemo } from "@barefootjs/client"
+const base = 'a b'
+const states = ['c', 'd'].join(' ')
+interface P { tone?: string }
+export function Widget(props: P) {
+  const classes = createMemo(() => \`\${base} \${states} \${props.className ?? ''} tail\`)
+  return <button class={classes()}>x</button>
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).toContain('Classes: "a b" + " " + "c d" + " " + in.ClassName + " tail"')
+    })
+
+    // A boolean ternary memo (`isChecked = ctrl() ? c() : i()`) renders its
+    // SSR zero as `false`, not the int `0`, so `aria-checked={isChecked()}`
+    // matches Hono's `aria-checked="false"`.
+    test('boolean ternary memo defaults to false, not 0', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createSignal, createMemo } from "@barefootjs/client"
+export function Toggle(props: { checked?: boolean; defaultChecked?: boolean }) {
+  const [internal] = createSignal(props.defaultChecked ?? false)
+  const [controlled] = createSignal<boolean | undefined>(props.checked)
+  const isControlled = createMemo(() => props.checked !== undefined)
+  const isChecked = createMemo(() => isControlled() ? controlled() : internal())
+  return <button aria-checked={isChecked()}>x</button>
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).toContain('IsChecked bool')
+      expect(types).toContain('IsChecked: false,')
+    })
+  })
+
+  describe('cross-component child rest-bag routing (#checkbox)', () => {
+    // A parent rendering a child with a non-param attribute whose name isn't a
+    // valid Go identifier (`<CheckIcon data-slot="..."/>`) must route it into
+    // the child's rest bag (`Props: map[string]any{...}`), not a hyphenated
+    // top-level field (`Data-slot:`), when the child has a `...props` rest
+    // spread. Requires the child's shape registered first.
+    test('routes a hyphenated non-param child attr into the child rest bag', () => {
+      const adapter = new GoTemplateAdapter()
+      const childSource = `
+"use client"
+export function Leaf({ size, ...props }: { size?: string }) {
+  return <span {...props}>{size}</span>
+}
+`
+      const childIr = compileToIR(childSource, adapter)
+      adapter.registerChildComponentShape(childIr)
+      const parentSource = `
+"use client"
+import { Leaf } from './leaf'
+export function Host() {
+  return <div><Leaf data-slot="indicator" size="sm" /></div>
+}
+`
+      const types = adapter.generateTypes(compileToIR(parentSource, adapter))!
+      // Non-param hyphenated attr lands in the rest bag, not a Data-slot field.
+      expect(types).not.toContain('Data-slot:')
+      expect(types).toContain('Props: map[string]any{"data-slot": "indicator"}')
+      // A declared param (`size`) still binds as a top-level field.
+      expect(types).toContain('Size: "sm"')
+    })
+  })
+
+  describe('nullish optional-attribute omission (textarea rows)', () => {
+    // An optional, no-default prop whose Go field type resolves to
+    // `interface{}` (nillable) is emitted with a `ne .X nil` guard so an
+    // unset value DROPS the attribute instead of rendering `attr=""` —
+    // matching Hono's nullish-attribute omission. Concrete/defaulted
+    // props are never nil and stay unconditional.
+    test('guards a nillable optional attr with {{if ne .X nil}}', () => {
+      const source = `
+function C({ rows }: { rows?: number }) {
+  return <textarea rows={rows} />
+}
+`
+      const { template } = compileAndGenerate(source)
+      expect(template).toContain('{{if ne .Rows nil}}rows="{{.Rows}}"{{end}}')
+      // Must NOT emit the bare unconditional form.
+      expect(template).not.toMatch(/(?<!if ne \.Rows nil}})rows="\{\{\.Rows\}\}"/)
+    })
+
+    test('leaves a concrete/defaulted attr unconditional (scope did not widen)', () => {
+      const source = `
+function C({ value = '' }: { value?: string }) {
+  return <textarea value={value} />
+}
+`
+      const { template } = compileAndGenerate(source)
+      // `value` has a destructure default → concrete `string` field →
+      // never nil → emitted unconditionally, exactly like Hono's value="".
+      expect(template).toContain('value="{{.Value}}"')
+      expect(template).not.toContain('if ne .Value nil')
+    })
+  })
+
   describe('loop body outer-scope references (#1677)', () => {
     test('references an outer signal inside a loop via $ root scope, not the element', () => {
       // Inside `{{range $_, $t := .Items}}` the dot is rebound to the loop