@barefootjs/go-template 0.6.1 → 0.8.0

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

@@ -76,16 +76,24 @@ runAdapterConformanceTests({
     // option fixed on the Hono side. Separate follow-up.
     'toggle-shared',
     'props-reactivity-comparison',
-    // #1467 Phase 2a: first `site/ui` source-root fixture. Button
-    // compiles cleanly on the Go adapter (no diagnostic), but its
-    // variant/size class composition (`Record<…>[key]` indexed object
-    // literals) and `applyRestAttrs` spread haven't been validated for
-    // byte-parity against the Hono reference under Go's template
-    // semantics. Cross-adapter parity for the `site/ui` corpus is
-    // explicitly Phase 3 ("cross-adapter parity (Mojo/Go templates)"),
-    // so Button participates only in Hono SSR conformance + the
-    // fixture-hydrate runtime layer for now.
-    'button',
+    // #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` is a pass-through
+    // native control.)
+    //
+    // `textarea` now participates: its conditional inline-object spread
+    // (`{...(describedBy ? {...} : {})}`) lowers via
+    // `buildConditionalSpreadInitializer`, and its optional
+    // `rows={rows}` attribute is omitted when nil via the nillable-field
+    // guard in `elementAttrEmitter.emitExpression`
+    // (`{{if ne .Rows nil}}rows="{{.Rows}}"{{end}}`), matching Hono's
+    // nullish-attribute omission.
+    'toggle',
+    'switch',
+    'checkbox',
+    'kbd',
   ],
   // Per-fixture build-time contracts for shapes the Go template
   // adapter intentionally refuses to lower. Lives here (not on the
@@ -298,6 +306,28 @@ export function Counter(props: { initial?: number }) {
       expect(result.types).toContain('Count int')
     })
 
+    test('module pure-string const referenced in className inlines the literal (#1467 Phase 2b)', () => {
+      // A module-scope `const X = 'literal'` used inside a className
+      // template literal must inline its value, NOT emit `{{.X}}` against a
+      // Props field that never exists (Go fails `can't evaluate field X`).
+      // Hono inlines it at runtime; this restores byte-parity.
+      const source = `
+"use client"
+const labelClasses = 'flex items-center group-data-[disabled=true]:opacity-50'
+export function Label({ className = '' }: { className?: string }) {
+  return <label className={\`\${labelClasses} \${className}\`} />
+}
+`
+      const { template, types } = compileAndGenerate(source)
+      // The literal is inlined as a Go string literal, escaped tokens intact.
+      expect(template).toContain(
+        '{{"flex items-center group-data-[disabled=true]:opacity-50"}}',
+      )
+      // No struct-field reference to the const, and no Props field for it.
+      expect(template).not.toContain('.LabelClasses')
+      expect(types).not.toContain('LabelClasses')
+    })
+
     test('dynamic loop with child component → NewXxxProps carries a populate-this-slice doc comment (#1442 echo TodoApp repro)', () => {
       // Regression: a `todos().map(t => <TodoItem todo={t} />)` loop with a
       // dynamic array (signal getter, not a static prop) declares
@@ -795,6 +825,90 @@ 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('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

package/src/__tests__/slot-dynamic-tag.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Pins the Go template lowering of the `Slot` component's dynamic tag.
+ *
+ * `Slot` does `const Tag = children.tag; return <Tag …>{…}</Tag>` inside
+ * an `if (isValidElement(children)) { … }` block. A naive lowering would:
+ *   1. emit `{{template "Tag" .TagSlot0}}` — a template that can never be
+ *      registered. Go's html/template escape-walks ALL registered
+ *      templates (even dead branches), so the whole render fails with
+ *      `no such template "Tag"`.
+ *   2. lower `isValidElement(children)` to a bogus `.IsValidElement`
+ *      struct-field access (a user type-guard predicate Go can't evaluate).
+ *
+ * The `dynamicTag` IR flag (jsx-to-ir) plus the call-condition fallback
+ * (go-template-adapter) defuse both. This test asserts the *emitted Go
+ * template string* carries neither pathology, complementing the full
+ * conformance render in `go-template-adapter.test.ts`.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { GoTemplateAdapter } from '../adapter/go-template-adapter'
+import { compileJSX } from '@barefootjs/jsx'
+
+// The committed SSR-precompiled Slot module the conformance harness feeds
+// to Go (`children.tag` dynamic tag inside an isValidElement guard).
+const SLOT_SSR = `/** @jsxImportSource hono/jsx */
+interface SlotProps { children?: unknown; className?: string; [key: string]: unknown }
+function isValidElement(element: unknown): element is { tag: unknown; props: Record<string, unknown> } {
+  return !!(element && typeof element === 'object' && 'tag' in element && 'props' in element)
+}
+export function Slot({ children, className, ...props }: SlotProps) {
+  if (children && isValidElement(children)) {
+    const Tag = children.tag as any
+    const childProps = children.props
+    const childClass = (childProps.className as string) || ''
+    const childChildren = childProps.children
+    const mergedClass = [className, childClass].filter(Boolean).join(' ')
+    return <Tag {...childProps} {...props} className={mergedClass || undefined}>{childChildren}</Tag>
+  }
+  return <>{children}</>
+}
+`
+
+describe('Slot dynamic-tag Go lowering', () => {
+  test('emitted Go template has no `{{template "Tag"` call and no `.IsValidElement` field', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(SLOT_SSR, 'slot.tsx', { adapter, componentName: 'Slot' })
+    expect(result.errors.filter(e => e.severity === 'error')).toEqual([])
+    const template = result.files.find(f => f.type === 'markedTemplate')!
+    expect(template).toBeDefined()
+    expect(template.content).not.toContain('{{template "Tag"')
+    expect(template.content).not.toContain('.IsValidElement')
+  })
+
+  test('`isValidElement(children)` lowers to a real truthiness check — no diagnostic, no forced literal', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(SLOT_SSR, 'slot.tsx', { adapter, componentName: 'Slot' })
+    // The guard evaluates faithfully on Go (element ⟺ has children to render),
+    // so there is neither an error nor an ignorable warning, and the condition
+    // is a real `.Children` truthiness check rather than a fudged literal.
+    expect(result.errors).toEqual([])
+    const template = result.files.find(f => f.type === 'markedTemplate')!
+    expect(template.content).toContain('.Children')
+  })
+
+  test('a non-isValidElement user predicate (e.g. `isAdmin`) is a hard BF102 error, not a silent literal', () => {
+    const SRC = `/** @jsxImportSource hono/jsx */
+declare function isAdmin(u: unknown): boolean
+export function Gate({ user }: { user?: unknown }) {
+  return <div>{isAdmin(user) ? <span>secret</span> : null}</div>
+}
+`
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(SRC, 'gate.tsx', { adapter, componentName: 'Gate' })
+    const errors = result.errors.filter(e => e.severity === 'error')
+    expect(
+      errors.some(e => e.code === 'BF102' && /cannot be evaluated/i.test(e.message))
+    ).toBe(true)
+  })
+})