@barefootjs/go-template 0.1.2 → 0.2.0

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

@@ -22,14 +22,6 @@ runAdapterConformanceTests({
   // `<!--bf-cond-start:sN-->` / `<!--bf-cond-end:sN-->` comment pairs)
   // is now collapsed by `normalizeHTML` in adapter-tests (#1266).
   //
-  // `nullish-coalescing-jsx` / `return-nullish-coalescing` have a
-  // separate semantic divergence: the Go template's `{{if ne .Banner
-  // ""}}` condition treats an unset `Banner` (Go nil) as `!= ""` and
-  // takes the truthy branch with empty content, while Hono's JS
-  // `??` operator falls through to the JSX default. That's a Go-
-  // adapter branch-selection bug — fixing it is out of scope for
-  // #1266.
-  //
   // `return-map` uses a `data-key` serialisation shape that differs
   // between Hono (runtime helper) and Go (template variable) in a
   // way that isn't structural — leaving it on `skipJsx` until a
@@ -43,8 +35,6 @@ runAdapterConformanceTests({
   // `BF104` at build time instead of silently emitting invalid
   // template syntax (#1266).
   skipJsx: [
-    'nullish-coalescing-jsx',
-    'return-nullish-coalescing',
     'return-map',
     // #1297 fixed the harness-side IR emission gate (multi-component
     // sources now emit one `ir` file per component, and the harness
@@ -1034,6 +1024,116 @@ export function ItemChecker() {
     })
   })
 
+  describe('findLast/findLastIndex - adapter specific', () => {
+    test('renders findLast() with equality predicate via bf_find_last', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { name: string; done: boolean }
+
+export function ItemChecker() {
+  const [items, setItems] = createSignal<Item[]>([])
+  return <div>{items().findLast(t => t.done) ? 'Found' : 'Not found'}</div>
+}
+`)
+      expect(result.template).toContain('bf_find_last .Items "Done" true')
+      expect(result.template).toContain('Found')
+    })
+
+    test('renders findLast() with complex predicate via range without break', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; category: string }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  const [type, setType] = createSignal('')
+  return <div>{items().findLast(t => t.price > 100 && t.category === type())}</div>
+}
+`)
+      expect(result.template).toContain('{{range')
+      expect(result.template).toContain('$bf_r')
+      expect(result.template).not.toContain('{{break}}')
+    })
+
+    test('renders findLastIndex() with equality predicate via bf_find_last_index', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { name: string; done: boolean }
+
+export function ItemChecker() {
+  const [items, setItems] = createSignal<Item[]>([])
+  return <div>idx: {items().findLastIndex(t => t.done)}</div>
+}
+`)
+      expect(result.template).toContain('bf_find_last_index .Items "Done" true')
+    })
+
+    test('renders findLastIndex() with complex predicate via range', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; active: boolean }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  return <div>{items().findLastIndex(t => t.price > 50 && t.active)}</div>
+}
+`)
+      const varMatch = result.template.match(/(\$bf_r\d+) := -1/)
+      expect(varMatch).not.toBeNull()
+      expect(result.template).toContain(`${varMatch![1]} = $i`)
+      expect(result.template).not.toContain('{{break}}')
+    })
+
+    test('findLast() complex predicate in IR-level ternary works via preamble splitting', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; category: string }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  const [type, setType] = createSignal('')
+  return <div>{items().findLast(t => t.price > 100 && t.category === type()) ? 'yes' : 'no'}</div>
+}
+`, adapter)
+      const output = adapter.generate(ir)
+      expect(adapter.errors.filter(e => e.code === 'BF101')).toEqual([])
+      expect(output.template).toMatch(/\$bf_r\d+ := ""/)
+      expect(output.template).toContain('yes')
+    })
+
+    test('findLast() complex predicate in binary expression compiles via preamble hoisting', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; category: string }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  const [type, setType] = createSignal('')
+  return <div class={items().findLast(t => t.price > 100 && t.category === type()) === 'special' ? 'highlight' : 'normal'}>test</div>
+}
+`, adapter)
+      const output = adapter.generate(ir)
+      expect(adapter.errors.filter(e => e.code === 'BF101')).toEqual([])
+      expect(output.template).toMatch(/\$bf_r\d+ := ""/)
+      expect(output.template).toContain('eq')
+      expect(output.template).toContain('"special"')
+    })
+  })
+
   describe('component root scope comment propagation', () => {
     test('component root in client component outputs bfScopeComment', () => {
       const result = compileAndGenerate(`
@@ -1671,6 +1771,32 @@ export { A }`)
       expect(result.template).toContain('bf_join (bf_concat .Left .Right) " "')
     })
   })
+
+  describe('.entries() / .keys() / .values() iteration shapes (#1448 Tier B)', () => {
+    test('.entries().map(([i, v]) => ...) emits {{range $i, $v := .Items}}', () => {
+      const result = compileAndGenerate(`function A({ items }: { items: string[] }) {
+  return <ul>{items.entries().map(([i, v]) => <li key={i}>{i}: {v}</li>)}</ul>
+}
+export { A }`)
+      expect(result.template).toContain('{{range $i, $v := .Items}}')
+    })
+
+    test('.keys().map(k => ...) emits {{range $k, $_ := .Items}}', () => {
+      const result = compileAndGenerate(`function A({ items }: { items: string[] }) {
+  return <ul>{items.keys().map(k => <li key={k}>{k}</li>)}</ul>
+}
+export { A }`)
+      expect(result.template).toContain('{{range $k, $_ := .Items}}')
+    })
+
+    test('.values().map(v => ...) emits standard {{range $_, $v := .Items}}', () => {
+      const result = compileAndGenerate(`function A({ items }: { items: string[] }) {
+  return <ul>{items.values().map(v => <li key={v}>{v}</li>)}</ul>
+}
+export { A }`)
+      expect(result.template).toContain('{{range $_, $v := .Items}}')
+    })
+  })
 })
 
 // =============================================================================
@@ -1708,6 +1834,10 @@ import { fixture as arraySortFieldDescFixture } from '../../../adapter-tests/fix
 import { fixture as arraySortPrimitiveFixture } from '../../../adapter-tests/fixtures/methods/array-sort-primitive'
 import { fixture as arraySortLocaleFixture } from '../../../adapter-tests/fixtures/methods/array-sort-locale'
 import { fixture as arrayToSortedFixture } from '../../../adapter-tests/fixtures/methods/array-toSorted'
+// #1448 Tier B — .entries / .keys / .values iteration shapes.
+import { fixture as arrayEntriesFixture } from '../../../adapter-tests/fixtures/methods/array-entries'
+import { fixture as arrayKeysFixture } from '../../../adapter-tests/fixtures/methods/array-keys'
+import { fixture as arrayValuesFixture } from '../../../adapter-tests/fixtures/methods/array-values'
 
 describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
   const cases = [
@@ -1738,6 +1868,11 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
     { fixture: arraySortPrimitiveFixture, expect: 'bf_sort .Nums "self" "" "numeric" "asc"' },
     { fixture: arraySortLocaleFixture,    expect: 'bf_sort .Names "self" "" "string" "asc"' },
     { fixture: arrayToSortedFixture,      expect: 'bf_sort .Nums "self" "" "numeric" "asc"' },
+    // #1448 Tier B — iteration shapes. These are loop-level
+    // patterns (range binding order), not helper function calls.
+    { fixture: arrayEntriesFixture,       expect: '{{range $i, $v := .Items}}' },
+    { fixture: arrayKeysFixture,          expect: '{{range $k, $_ := .Items}}' },
+    { fixture: arrayValuesFixture,        expect: '{{range $_, $v := .Items}}' },
   ]
 
   for (const { fixture, expect: expectedHelper } of cases) {