@barefootjs/go-template 0.18.7 → 0.19.1

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

@@ -119,6 +119,7 @@ runAdapterConformanceTests({
     // (#1897) data-table no longer skipped — loop body children + wrapper
     // struct + block-body memo baking render correctly on Go.
   ]),
+  skipDataPoints: new Set<string>(),
   onRenderError: (err, id) => {
     if (err instanceof GoNotAvailableError) {
       console.log(`Skipping [${id}]: ${err.message}`)
@@ -506,9 +507,11 @@ export function Counter(props: { initial?: number }) {
       expect(result.types).toBeDefined()
       const types = result.types!
 
-      // Hoist: `initial := in.Initial` + zero-check + fallback assign.
-      expect(types).toContain('initial := in.Initial')
-      expect(types).toMatch(/if initial == 0 \{\s*initial = 99\s*\}/)
+      // The fallback applies only when the prop is ABSENT: an explicit
+      // `Initial: 0` is honoured (JS `0 ?? 99` is `0`, #2248).
+      expect(types).toContain('Initial interface{}')
+      expect(types).toContain('var initial int = 99')
+      expect(types).toMatch(/if in\.Initial != nil \{\s*initial = bf\.ToInt\(in\.Initial\)\s*\}/)
 
       // Prop, signal, and memo all reference the hoisted variable.
       expect(types).toContain('Initial: initial,')
@@ -553,8 +556,11 @@ export function Label(props: { label?: string }) {
 `)
       const result = adapter.generate(ir)
       const types = result.types!
-      expect(types).toContain('label := in.Label')
-      expect(types).toMatch(/if label == ""\s*\{\s*label = "Default"\s*\}/)
+      // An explicit `Label: ""` input stays empty (JS `'' ?? 'Default'` is
+      // `''`, #2248).
+      expect(types).toContain('Label interface{}')
+      expect(types).toContain('var label string = "Default"')
+      expect(types).toMatch(/if in\.Label != nil \{\s*label = in\.Label\.\(string\)\s*\}/)
       expect(types).toContain('Label: label,')
       // Signal name `text` differs from prop name `label`, so the
       // signal field gets its own entry that resolves through the
@@ -562,12 +568,11 @@ export function Label(props: { label?: string }) {
       expect(types).toContain('Text: label,')
     })
 
-    test('hoists `props.X ?? true` against the bool zero (#1423 review)', () => {
-      // Bool-true falls through the same hoist path as int / string —
-      // the asymmetry is documented (caller can't thread "explicit
-      // false" through because Go's bool zero IS false), but emitting
-      // a hoisted local matches the int case's shape so a derived
-      // memo can inherit it.
+    test('hoists `props.X ?? true` against nil (#1423 review, #2248)', () => {
+      // Bool-true falls through the same hoist path as int / string. The
+      // interface{} field is nil only when the caller omitted the prop, so
+      // an explicit `Checked: false` survives (JS `false ?? true` is
+      // `false`).
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`
 "use client"
@@ -580,12 +585,124 @@ export function Check(props: { checked?: boolean }) {
 `)
       const result = adapter.generate(ir)
       const types = result.types!
-      expect(types).toContain('checked := in.Checked')
-      expect(types).toMatch(/if checked == false\s*\{\s*checked = true\s*\}/)
+      expect(types).toContain('Checked interface{}')
+      expect(types).toContain('var checked bool = true')
+      expect(types).toMatch(/if in\.Checked != nil \{\s*checked = in\.Checked\.\(bool\)\s*\}/)
       expect(types).toContain('Checked: checked,')
       expect(types).toContain('C: checked,')
     })
 
+    test('hoists the DESTRUCTURED `x ?? N` seed via signal.parsed (#2259)', () => {
+      // Destructured components have no `propsObjectName`, so the seed's
+      // prop reference is a bare identifier — matched structurally on the
+      // signal's ParsedExpr, then routed through the same nullish flip +
+      // hoisted-var machinery as `props.size ?? 1` (#2248/#2252 parity).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter({ size }: { size?: number }) {
+  const [count, setCount] = createSignal(size ?? 1)
+  return <div>{count()}</div>
+}
+`)
+      const result = adapter.generate(ir)
+      const types = result.types!
+      expect(types).toContain('Size interface{}')
+      expect(types).toContain('var size int = 1')
+      expect(types).toMatch(/if in\.Size != nil \{\s*size = bf\.ToInt\(in\.Size\)\s*\}/)
+      expect(types).toContain('Size: size,')
+      expect(types).toContain('Count: size,')
+    })
+
+    test('destructured `x ?? 0` stays concrete and seeds the prop directly (#2259)', () => {
+      // A zero-equivalent fallback earns no nillable flip (nil and the Go
+      // zero value land on the same output), so the field keeps its scalar
+      // type and the signal seeds straight off the input — NOT the literal
+      // `0` the pre-#2259 lowering emitted for the unrecognized identifier
+      // form.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter({ size }: { size?: number }) {
+  const [count, setCount] = createSignal(size ?? 0)
+  return <div>{count()}</div>
+}
+`)
+      const result = adapter.generate(ir)
+      const types = result.types!
+      expect(types).toContain('Size int')
+      expect(types).not.toContain('Size interface{}')
+      expect(types).toContain('Size: in.Size,')
+      expect(types).toContain('Count: in.Size,')
+    })
+
+    test('negative fallback (`?? -1`) hoists in both prop styles (#2259 review)', () => {
+      // `-1` parses as unary minus around a number literal, not a literal —
+      // the structural seed match must reconstruct the sign, in the
+      // props-object form (where it preempts the regex path) and the
+      // destructured form alike.
+      for (const [params, ref] of [
+        ['props: { size?: number }', 'props.size'],
+        ['{ size }: { size?: number }', 'size'],
+      ]) {
+        const adapter = new GoTemplateAdapter()
+        const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter(${params}) {
+  const [count, setCount] = createSignal(${ref} ?? -1)
+  return <div>{count()}</div>
+}
+`, adapter)
+        const types = adapter.generate(ir).types!
+        expect(types).toContain('Size interface{}')
+        expect(types).toContain('var size int = -1')
+        expect(types).toContain('Count: size,')
+      }
+    })
+
+    test('string fallback with quotes survives the structural match unmangled (#2259 review)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Label({ label }: { label?: string }) {
+  const [text, setText] = createSignal(label ?? 'say "hi"')
+  return <div>{text()}</div>
+}
+`, adapter)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('var label string = "say \\"hi\\""')
+      expect(types).not.toContain('\\\\')
+    })
+
+    test('destructure DEFAULT keeps the concrete-typed applyGoFallback baking (#2259)', () => {
+      // `{ size = 5 }` never sees a nullish binding in JS (the default
+      // already applied), so it must stay excluded from the nillable flip
+      // and keep the zero-check baking on the concrete field.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter({ size = 5 }: { size?: number }) {
+  const [count, setCount] = createSignal(size)
+  return <div>{count()}</div>
+}
+`)
+      const result = adapter.generate(ir)
+      const types = result.types!
+      expect(types).toContain('Size int')
+      expect(types).not.toContain('Size interface{}')
+      expect(types).toContain('Size: func() int { if in.Size == 0 { return 5 }; return in.Size }(),')
+    })
+
     test('skips hoist for zero-equivalent string and float fallbacks (#1423 review)', () => {
       // The skip predicate compares the Go fallback against the
       // type's zero literal — covers `?? ''` (string) and `?? 0.0`
@@ -979,10 +1096,13 @@ function Box({ describedBy }: { describedBy?: string }) {
       // 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.
+      // optional prop resolves to a concrete `string` (#2259) — it is
+      // consumed only inside the spread condition, not as a bare attr, so
+      // no nillable flip — and the field-typed condition is a faithful
+      // `!= ""` truthiness test rather than reflection: JS string
+      // truthiness IS non-emptiness, and an absent prop zeroes to `""`.
       expect(types).toContain('Spread_0: func() map[string]any {')
-      expect(types).toContain('if bf.Truthy(in.DescribedBy) {')
+      expect(types).toContain('if in.DescribedBy != "" {')
       expect(types).toContain('return map[string]any{"aria-describedby": in.DescribedBy}')
       expect(types).toContain('return map[string]any{}')
     })
@@ -1151,10 +1271,15 @@ export function Widget(props: P) {
       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', () => {
+    // A boolean ternary memo (`isChecked = ctrl() ? c() : i()`) types its
+    // SSR field as `bool` (not `int`), so `aria-checked={isChecked()}`
+    // matches Hono's `aria-checked="false"` shape. Since #2260, `checked`'s
+    // presence is expressible (nillable `interface{}`), so the constructor
+    // bakes a runtime presence check + type-asserted read instead of the
+    // pre-#2260 unconditional `false` — see the `Controlled/derived
+    // boolean props honour a caller-supplied true` describe block below for
+    // the caller-supplied-`true` case this unlocks.
+    test('boolean ternary memo types as bool, resolves controlled presence at SSR', () => {
       const adapter = new GoTemplateAdapter()
       const source = `
 "use client"
@@ -1169,7 +1294,9 @@ export function Toggle(props: { checked?: boolean; defaultChecked?: boolean }) {
 `
       const types = adapter.generateTypes(compileToIR(source, adapter))!
       expect(types).toContain('IsChecked bool')
-      expect(types).toContain('IsChecked: false,')
+      expect(types).toContain(
+        'IsChecked: func() bool { if in.Checked != nil { return func() bool { if v, ok := in.Checked.(bool); ok { return v }; return false }() }; return in.DefaultChecked }(),',
+      )
     })
   })
 
@@ -3631,8 +3758,9 @@ export function C(props: Props) {
     const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
     // The `{}` fallback lowers to the safe `""` Go string sentinel — never the
     // `[UNSUPPORTED: …]` marker text, which would break `text/template` parsing
-    // once spliced as an `or` operand.
-    expect(template).toContain('{{or .Config ""}}')
+    // once spliced as an operand. `??` on a nillable prop lowers to the
+    // nil-testing `bf_nullish` (#2248), equally valid template syntax.
+    expect(template).toContain('{{bf_nullish .Config ""}}')
     expect(template).not.toContain('UNSUPPORTED')
   })
 
@@ -4569,3 +4697,134 @@ export function List() {
     }
   })
 })
+
+// #2254: `??` in CONDITION position (ternaries/`{{if}}` via
+// `convertConditionToGo` → `renderConditionExpr`'s `logical` case) still
+// emitted Go's truthiness-based `or` even for a nillable-lowered prop, so a
+// present-but-empty (`''`) value wrongly fell back to the `??` default —
+// diverging from JS, where `??` only falls back on null/undefined. The
+// sibling `logical()` emitter (used for non-condition expression positions,
+// e.g. plain interpolation) already routed nillable operands through
+// `bf_nullish` since #2248/#2252; this brings the condition-position
+// emitter in line with it.
+describe('GoTemplateAdapter - #2254 `??` in condition position on a nillable prop', () => {
+  test('ternary test comparing `props.label ?? "Default"` lowers to bf_nullish, not or', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(`
+"use client"
+type Props = { label?: string }
+export function C(props: Props) {
+  return <div>{(props.label ?? 'Default') === 'Default' ? <span>fallback</span> : <span>set</span>}</div>
+}
+`.trimStart(), 'test.tsx', { adapter })
+    expect(result.errors ?? []).toEqual([])
+    const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
+    expect(template).toContain('bf_nullish .Label "Default"')
+    expect(template).not.toContain('or .Label "Default"')
+  })
+
+  test('end-to-end via real `go run`: a present-but-empty label does NOT take the ?? default branch', async () => {
+    try {
+      const html = await renderGoTemplateComponent({
+        source: `
+'use client'
+type Props = { label?: string }
+export function C(props: Props) {
+  return <div>{(props.label ?? 'Default') === 'Default' ? <span>fallback</span> : <span>set</span>}</div>
+}
+`,
+        adapter: new GoTemplateAdapter(),
+        props: { label: '' },
+      })
+      // JS: '' ?? 'Default' keeps '' (present, not nullish) → '' === 'Default'
+      // is false → the "set" branch renders. The pre-fix `or` lowering would
+      // truthiness-fallback the empty string to 'Default' and wrongly render
+      // "fallback" instead.
+      expect(html).toContain('>set</span>')
+      expect(html).not.toContain('>fallback</span>')
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) {
+        console.log('Skipping #2254 e2e: go command not found')
+        return
+      }
+      throw err
+    }
+  })
+
+  test('an omitted label DOES take the ?? default branch', async () => {
+    try {
+      const html = await renderGoTemplateComponent({
+        source: `
+'use client'
+type Props = { label?: string }
+export function C(props: Props) {
+  return <div>{(props.label ?? 'Default') === 'Default' ? <span>fallback</span> : <span>set</span>}</div>
+}
+`,
+        adapter: new GoTemplateAdapter(),
+        props: {},
+      })
+      expect(html).toContain('>fallback</span>')
+      expect(html).not.toContain('>set</span>')
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) {
+        console.log('Skipping #2254 e2e: go command not found')
+        return
+      }
+      throw err
+    }
+  })
+})
+
+// Review finding on #2271 (the #2254 fix): `renderConditionExpr`'s `logical`
+// case wrapped operands via `needsParens` (AST-kind-based — only
+// `logical`/`unary`/`conditional`), missing any OTHER multi-token rendering
+// (`len .X`, `bf_add a b`, a call). Unwrapped, Go's `and`/`or`/`bf_nullish`
+// (all prefix builtins) parse a multi-token operand as extra sibling args
+// instead of one operand. Switched to `wrapIfMultiToken` (whitespace-based,
+// on the rendered string), matching the main `logical()` emitter.
+describe('GoTemplateAdapter - condition-position logical operand wrapping (#2271 review)', () => {
+  test('a `.length` (member → "len .X") operand of `&&` inside a ternary TEST is parenthesized', () => {
+    // A bare `{cond && <Elem/>}` is recognized as JSX conditional-rendering
+    // shorthand and its test is extracted directly, never reaching
+    // `renderConditionExpr`'s `logical` case as a literal `&&` node — so the
+    // `&&` must be nested inside an explicit ternary test to exercise it.
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(`
+"use client"
+type Item = { id: number }
+export function C({ items, enabled }: { items: Item[]; enabled: boolean }) {
+  return <div>{(items.length && enabled) ? <span>on</span> : <span>off</span>}</div>
+}
+`.trimStart(), 'test.tsx', { adapter })
+    expect(result.errors ?? []).toEqual([])
+    const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
+    // `and (len .Items) .Enabled` — NOT the broken 3-sibling-arg
+    // `and len .Items .Enabled` a bare `needsParens` miss would produce.
+    expect(template).toContain('and (len .Items) .Enabled')
+  })
+
+  test('end-to-end via real `go run`: the multi-token `&&` ternary-test operand compiles and renders correctly', async () => {
+    try {
+      const html = await renderGoTemplateComponent({
+        source: `
+'use client'
+type Item = { id: number }
+export function C({ items, enabled }: { items: Item[]; enabled: boolean }) {
+  return <div>{(items.length && enabled) ? <span>on</span> : <span>off</span>}</div>
+}
+`,
+        adapter: new GoTemplateAdapter(),
+        props: { items: [{ id: 1 }], enabled: true },
+      })
+      expect(html).toContain('>on</span>')
+      expect(html).not.toContain('>off</span>')
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) {
+        console.log('Skipping #2271 review e2e: go command not found')
+        return
+      }
+      throw err
+    }
+  })
+})

package/src/adapter/emit-context.ts

@@ -41,14 +41,23 @@ export interface GoEmitContext {
     preParsed?: ParsedExpr,
   ): { condition: string; preamble: string }
 
-  /** Extract the prop name from a `props.X ?? …` initial value, or null. */
-  extractPropNameFromInitialValue(initialValue: string): string | null
+  /**
+   * Extract the prop name from a `props.X ?? …` initial value — or, given
+   * `preParsed` in a destructured component, an `x ?? …` identifier form —
+   * or null. Callers validate the name against `propsParams`.
+   */
+  extractPropNameFromInitialValue(initialValue: string, preParsed?: ParsedExpr): string | null
 
   /**
-   * Parse a signal-time initial value `props.X ?? <literal>` into the source
-   * prop name and the Go-formatted fallback, or null when it isn't that shape.
+   * Parse a signal-time initial value `props.X ?? <literal>` (or the
+   * destructured `x ?? <literal>` form when `preParsed` is given) into the
+   * source prop name and the Go-formatted fallback, or null when it isn't
+   * that shape. Callers validate the name against `propsParams`.
    */
-  extractPropFallback(initialValue: string): { propName: string; goFallback: string } | null
+  extractPropFallback(
+    initialValue: string,
+    preParsed?: ParsedExpr,
+  ): { propName: string; goFallback: string } | null
 
   /**
    * Inline a module string const by name as a Go double-quoted literal