@barefootjs/go-template 0.14.0 → 0.15.0

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

@@ -11,7 +11,7 @@ import {
   TemplatePrimitiveCaseId,
 } from '@barefootjs/adapter-tests'
 import { renderGoTemplateComponent, GoNotAvailableError } from '@barefootjs/go-template/test-render'
-import { compileJSX, type ComponentIR } from '@barefootjs/jsx'
+import { compileJSX, type ComponentIR, type IRExpression } from '@barefootjs/jsx'
 
 runAdapterConformanceTests({
   name: 'go-template',
@@ -34,9 +34,27 @@ runAdapterConformanceTests({
   // below, asserting that the adapter emits `BF101` / `BF103` /
   // `BF104` at build time instead of silently emitting invalid
   // template syntax (#1266).
-  // No JSX-render skips: every shared conformance fixture renders to Hono
-  // parity on real Go. Shapes the adapter intentionally refuses at build time
-  // are pinned in `expectedDiagnostics` below.
+  // JSX-render skips: every other shared conformance fixture renders to
+  // Hono parity on real Go — including the composed `site/ui` demo
+  // corpus (#1467 / #1896): JSX children passed to imported components
+  // now render through per-call-site companion defines executed via
+  // `bf_tmpl` + `bf_with_children` (see the bf runtime's
+  // `TemplateFuncMap`). Shapes the adapter intentionally refuses at
+  // build time are pinned in `expectedDiagnostics` below.
+  //
+  // `data-table` is the one remaining #1896 gap: its table body is a
+  // keyed `.map` over a `/* @client */`-sorted MEMO whose data is a
+  // module-const object array — a memo-derived dynamic loop of imported
+  // components, which the nested-component slice constructor can't bake
+  // yet (`item.ID` is on the loop datum, not the child's Input). Full
+  // coverage remains at the Hono SSR + fixture-hydrate layers.
+  //
+  // `search-params` (router v0.5) now renders on Go: `logical()` parenthesises
+  // its multi-token operands so `searchParams().get(k) ?? d` lowers to
+  // `{{or (.SearchParams.Get "sort") "none"}}`, and the generated structs carry
+  // a `SearchParams bf.SearchParams` binding (zero value → empty query → the
+  // author's default). See #1922; Mojo / Xslate stay skipped pending their own
+  // env-signal lowering + per-request Perl reader.
   skipJsx: [],
   // Per-fixture build-time contracts for shapes the Go template
   // adapter intentionally refuses to lower. Lives here (not on the
@@ -156,6 +174,8 @@ runAdapterConformanceTests({
     // the IR still declares (s6). See hono-adapter.test for the
     // contract.
     'todo-app',
+    // (#1897) data-table no longer skipped — loop body children + wrapper
+    // struct + block-body memo baking render correctly on Go.
   ]),
   onRenderError: (err, id) => {
     if (err instanceof GoNotAvailableError) {
@@ -196,6 +216,165 @@ function compileAndGenerate(source: string, adapter?: GoTemplateAdapter) {
 // Go-Template-Specific Tests
 // =============================================================================
 
+describe('GoTemplateAdapter - searchParams() env-signal lowering (#1922)', () => {
+  // `searchParams().get(k)` lowers to a method call on the canonical
+  // `.SearchParams` struct field, parenthesised inside `or` so the nullish
+  // fallback groups correctly.
+  test('lowers searchParams().get(k) to .SearchParams.Get and emits the struct binding', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+import { searchParams } from '@barefootjs/client'
+export function SortLabel() {
+  return <p>{searchParams().get('sort') ?? 'none'}</p>
+}
+`, adapter)
+    const { template, types } = adapter.generate(ir)
+    expect(template).toContain('{{or (.SearchParams.Get "sort") "none"}}')
+    expect(types).toContain('SearchParams bf.SearchParams')
+    expect(types).toContain('SearchParams: in.SearchParams')
+  })
+
+  // An aliased import binds the env signal to a different local name; the
+  // call `sp()` still resolves to the canonical `.SearchParams` field (the
+  // generated struct field name is fixed, not derived from the JS alias).
+  test('aliased import (`searchParams as sp`) resolves sp() to canonical .SearchParams', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+import { searchParams as sp } from '@barefootjs/client'
+export function SortLabel() {
+  return <p>{sp().get('sort') ?? 'none'}</p>
+}
+`, adapter)
+    const { template, types } = adapter.generate(ir)
+    expect(template).toContain('{{or (.SearchParams.Get "sort") "none"}}')
+    expect(template).not.toContain('.Sp.Get')
+    expect(types).toContain('SearchParams bf.SearchParams')
+  })
+})
+
+describe('GoTemplateAdapter - template-literal text lowering (#1933)', () => {
+  // A dynamic text node whose expression is a template literal lowers to a
+  // MIX of literal text + `{{...}}` actions (e.g. ` · #${tag}` →
+  // ` · #{{.Tag}}`). `renderExpression` must emit that mixed string as-is
+  // between bfTextStart/bfTextEnd — wrapping the whole thing in another
+  // `{{...}}` produces `{{ · #{{.Tag}}}}`, which `html/template` rejects at
+  // parse time with `unrecognized character in action: U+00B7 '·'`. This is
+  // the blog PostList status-line shape (the `· #${params().tag}` branch).
+  test('template literal in a conditional text branch keeps literal text outside the action', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createMemo, searchParams } from '@barefootjs/client'
+export function StatusLine() {
+  const tag = createMemo(() => searchParams().get('tag') ?? '')
+  return (
+    <div className="status">
+      {tag() ? \` · #\${tag()}\` : ''}
+    </div>
+  )
+}
+`, adapter)
+    const { template } = adapter.generate(ir)
+    // The literal text ` · #` must sit OUTSIDE the action, with only the
+    // interpolation as `{{...}}`. The broken form double-wraps it.
+    expect(template).not.toContain('{{ · #')
+    expect(template).toContain(' · #{{.Tag}}')
+  })
+
+  // Generalised: a template literal with a trailing interpolation in plain
+  // dynamic-text position (no conditional) must not be double-wrapped either.
+  test('template literal in plain dynamic text is not double-wrapped', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function Label() {
+  const [n, setN] = createSignal(0)
+  return <span>{\`count: \${n()}\`}</span>
+}
+`, adapter)
+    const { template } = adapter.generate(ir)
+    expect(template).not.toContain('{{count: ')
+    expect(template).toContain('count: {{.N}}')
+  })
+
+  // A bare string literal that merely *contains* `{{` (NOT a template literal)
+  // must still be WRAPPED in an action so html/template evaluates and escapes
+  // the string. Emitting the raw Go expression `"{{"` would print the literal
+  // quotes and bypass escaping. The skip-wrapping path is reserved for template
+  // literals + `{{`-leading action chains, so a substring `includes('{{')` check
+  // would wrongly treat this string as template text (#1937 review).
+  test('string literal containing "{{" is wrapped, not treated as template text', () => {
+    const adapter = new GoTemplateAdapter()
+    // Drive renderExpression directly: a JSX `{'{{'}` lowers `expr.expr` to the
+    // Go string literal `"{{"`, which contains `{{` but is not a template expr.
+    const out = adapter.renderExpression({ expr: `'{{'` } as IRExpression)
+    expect(out).toBe('{{"{{"}}')
+  })
+
+  // Control: a real template literal IS emitted as-is (mixed text + action),
+  // exercising the same code path with the opposite outcome.
+  test('template literal expression is emitted as-is via renderExpression', () => {
+    const adapter = new GoTemplateAdapter()
+    const out = adapter.renderExpression({ expr: '`a #${tag}`' } as IRExpression)
+    expect(out).toBe('a #{{.Tag}}')
+  })
+
+  // Attribute context: when a `${...}` interpolation lowers to a template
+  // literal, its literal text sits OUTSIDE the `{{...}}` actions and so bypasses
+  // html/template's attribute escaping. A `"` in a UnoCSS arbitrary value would
+  // break the surrounding `class="..."`. The literal parts must be escaped while
+  // interpolations stay as actions (#1937 review).
+  test('attribute-context template-literal interpolation escapes its literal text', () => {
+    const adapter = new GoTemplateAdapter()
+    const out = (adapter as unknown as {
+      substituteJsInterpolations(s: string): string
+    }).substituteJsInterpolations('content-["x"] ${`a-["y"] ${tag}`} z')
+    // The `"` from the nested template literal's literal part is escaped, not raw.
+    expect(out).toContain('a-[&quot;y&quot;] {{.Tag}}')
+    expect(out).not.toContain('a-["y"]')
+  })
+
+  // A template literal with an UNSUPPORTED interpolation lowers to the BF101
+  // sentinel `""` (the whole expression, not template text). It must still be
+  // WRAPPED (`{{""}}`) so the sentinel sits inside an action — not emitted raw,
+  // which would render literal quotes into the HTML. The template-literal
+  // classification must therefore be reported to `renderExpression` only for a
+  // *supported* parse, never for the error sentinel (#1937 review).
+  test('unsupported template-literal interpolation is wrapped, not emitted raw', () => {
+    const adapter = new GoTemplateAdapter()
+    const out = adapter.renderExpression({ expr: '`x ${new Date()}`' } as IRExpression)
+    expect(out).toBe('{{""}}')
+  })
+})
+
+// The wrap-or-not decision (`isTemplateFragment`) treats a leading `{{` as the
+// structural marker for "already a self-contained action block", and keys ONLY
+// template literals off their parsed kind. That is correct because of a
+// load-bearing invariant: a template literal is the *only* expression form that
+// interleaves author literal text with `{{...}}` actions, so every OTHER
+// fragment producer (ternary, find().prop, filter().length, …) emits a pure
+// action block that begins with `{{`. These tests pin that invariant: if a
+// future emitter prepends literal text to an action block, its output stops
+// starting with `{{`, this fails, and the fix is to give that shape a parsed
+// kind `isTemplateFragment` can detect (as template literals are handled) —
+// NOT to fall back to a fragile `{{` substring scan.
+describe('GoTemplateAdapter - template-fragment invariant (#1937)', () => {
+  const adapter = new GoTemplateAdapter()
+  const blockProducers: [string, string][] = [
+    ['ternary', "flag ? 'a' : 'b'"],
+    ['find().prop', 'items.find(i => i.active).name'],
+    ['findLast().prop', 'items.findLast(i => i.active).name'],
+    ['filter().length', 'items.filter(i => i.active).length'],
+  ]
+  for (const [label, expr] of blockProducers) {
+    test(`${label} lowers to a {{-leading action block (no leading literal text)`, () => {
+      const out = adapter.renderExpression({ expr } as IRExpression)
+      expect(out.startsWith('{{')).toBe(true)
+    })
+  }
+})
+
 describe('GoTemplateAdapter - Adapter Specific', () => {
   describe('generate - Go struct types', () => {
     test('deduplicates struct field when signal name matches prop name (#461)', () => {
@@ -1963,13 +2142,74 @@ export function Tagged(props: { className?: string }) {
       expect(numberResult.template).toContain('bf_number .V')
     })
 
+    test('Math.min(a, b) emits bf_min and parenthesises compound operands', () => {
+      // The blog's NowPlaying progress bar: `Math.min(100, (elapsed / TRACK) *
+      // 100)`. Math.min must lower to bf_min, the nested arithmetic must keep
+      // its inner parens (so bf_mul / bf_div get exactly two args each), and the
+      // module const TRACK must inline to its literal value.
+      const result = compileAndGenerate(`
+        'use client'
+        const TRACK = 8
+        export function Foo(props: { elapsed: number }) {
+          return <div data-x={Math.min(100, (props.elapsed / TRACK) * 100)}>hi</div>
+        }
+      `)
+      expect(result.template).toContain('bf_min 100 (bf_mul (bf_div .Elapsed 8) 100)')
+    })
+
+    test('Math.max(a, b) emits bf_max', () => {
+      const result = compileAndGenerate(`
+        'use client'
+        export function Foo(props: { a: number; b: number }) {
+          return <div data-x={Math.max(props.a, props.b)}>hi</div>
+        }
+      `)
+      expect(result.template).toContain('bf_max .A .B')
+    })
+
+    test('nested arithmetic parenthesises a compound operand', () => {
+      // Without wrapping, `(a / b) * c` would emit `bf_mul bf_div .A .B .C`,
+      // handing bf_mul four args. Each compound operand must be parenthesised.
+      const result = compileAndGenerate(`
+        'use client'
+        export function Foo(props: { a: number; b: number; c: number }) {
+          return <div data-x={(props.a / props.b) * props.c}>hi</div>
+        }
+      `)
+      expect(result.template).toContain('bf_mul (bf_div .A .B) .C')
+    })
+
+    test('module numeric const inlines its literal value', () => {
+      const result = compileAndGenerate(`
+        'use client'
+        const SIZE = 12
+        export function Foo(props: { n: number }) {
+          return <div data-x={props.n + SIZE}>hi</div>
+        }
+      `)
+      // SIZE inlines to 12 rather than emitting a bogus `.SIZE` Props field.
+      expect(result.template).toContain('bf_add .N 12')
+    })
+
+    test('module numeric const with separators inlines the stripped value', () => {
+      const result = compileAndGenerate(`
+        'use client'
+        const GAP = 100_000
+        export function Foo(props: { n: number }) {
+          return <div data-x={props.n + GAP}>hi</div>
+        }
+      `)
+      // 100_000 (TS numeric separator) → 100000; Go template literals reject "_".
+      expect(result.template).toContain('bf_add .N 100000')
+    })
+
     test('registry exposes the expected V1 callees', () => {
       // Pin the V1 surface so a future refactor doesn't accidentally
       // drop a primitive. New entries are additive — extend this
       // list rather than replace.
       const a = new GoTemplateAdapter()
       const keys = Object.keys(a.templatePrimitives ?? {}).sort()
-      expect(keys).toEqual(['JSON.stringify', 'Math.ceil', 'Math.floor', 'Math.round', 'Number', 'String'])
+      expect(keys).toEqual(['JSON.stringify', 'Math.ceil', 'Math.floor', 'Math.max', 'Math.min', 'Math.round', 'Number', 'String'])
     })
 
     test('unregistered identifier-path callee is NOT accepted by the registry', () => {
@@ -2116,13 +2356,33 @@ export function V({ variant }: { variant: 'a' | 'b' }) {
       // The ClassName field MUST be set on the SlotInput literal.
       expect(goCode).toContain('ClassName:')
       // The IIFE shape: a self-invoking func that switches on the
-      // variant key and returns the matching case.
+      // variant key and returns the matching case. The switch key goes
+      // through `fmt.Sprint` (not a `.(string)` assertion) so it
+      // compiles for both `interface{}`-typed fields and the `string`
+      // fields the shared inherited-prop augmentation synthesises
+      // (#1896).
       expect(goCode).toContain('func() string {')
-      expect(goCode).toContain('in.Variant.(string)')
+      expect(goCode).toContain('switch fmt.Sprint(in.Variant)')
       expect(goCode).toContain('case "a": return "class-a"')
       expect(goCode).toContain('case "b": return "class-b"')
     })
 
+    test('string-tolerant eq keeps a compound operand grouped (#1903 review)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+export function T(props: { placement?: 'top' | 'left' }) {
+  return <div data-side={(props.placement ?? 'top') === 'left' ? 'l' : 'o'}>x</div>
+}
+`, adapter)
+      const out = adapter.generate(ir)
+      // The non-literal side routes through bf_string as ONE argument:
+      // `(bf_string (or .Placement "top"))`. Stripping the inner parens
+      // would hand the parser three arguments and fail at runtime with
+      // `bf_string: want 1 got 3`.
+      expect(out.template).toContain('eq (bf_string (or .Placement "top")) "left"')
+      expect(out.template).not.toContain('bf_string or ')
+    })
+
     test('intermediate-const composition (Button shape) carries through', () => {
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`