@barefootjs/jsx 0.16.0 → 0.17.1

package/src/__tests__/flatmap-support.test.ts

@@ -1,218 +0,0 @@
-/**
- * BarefootJS Compiler - .flatMap() support (#1554 / #1448 Tier C)
- *
- * flatMap callbacks containing JSX must compile to valid JS for
- * JavaScript runtime adapters (Hono, CSR). Template-language adapters
- * (Go, Mojo) do not support flatMap — the workaround is .map() + Fragment.
- */
-
-import { describe, test, expect } from 'bun:test'
-import { compileJSX } from '../compiler'
-import { TestAdapter } from '../adapters/test-adapter'
-import { HonoAdapter } from '../../../../packages/adapter-hono/src/adapter/hono-adapter'
-
-const adapter = new TestAdapter()
-
-describe('.flatMap() — simple arrow with array literal', () => {
-  test('arrow body returning [<A/>, <B/>] compiles to flatMap with valid JS', () => {
-    const source = `
-      'use client'
-
-      export function DL(props: { items: { term: string; def: string }[] }) {
-        return (
-          <dl>
-            {props.items.flatMap((item, i) => [
-              <dt key={\`dt-\${i}\`}>{item.term}</dt>,
-              <dd key={\`dd-\${i}\`}>{item.def}</dd>
-            ])}
-          </dl>
-        )
-      }
-    `
-    const result = compileJSX(source, 'DL.tsx', { adapter })
-    expect(result.errors).toHaveLength(0)
-
-    const clientJs = result.files.find(f => f.type === 'clientJs')!
-    expect(clientJs.content).toContain('.flatMap(')
-    expect(clientJs.content).toContain('.join(')
-    // Template contains compiled HTML (not raw JSX)
-    expect(clientJs.content).toContain('item.term')
-    expect(clientJs.content).toContain('item.def')
-  })
-})
-
-describe('.flatMap() — complex block body with conditional returns', () => {
-  test('block body with variable JSX and conditional returns produces valid client JS', () => {
-    const source = `
-      'use client'
-
-      export function Timeline(props: { frames: { label: string }[] }) {
-        return (
-          <div>
-            {props.frames.flatMap((frame, i) => {
-              const panel = (
-                <ResizablePanel key={\`p-\${i}\`}>
-                  {i + 1}
-                </ResizablePanel>
-              )
-              if (i === 0) return [panel]
-              return [<ResizableHandle key={\`h-\${i}\`} />, panel]
-            })}
-          </div>
-        )
-      }
-    `
-    const result = compileJSX(source, 'Timeline.tsx', { adapter })
-    expect(result.errors).toHaveLength(0)
-
-    const clientJs = result.files.find(f => f.type === 'clientJs')!
-    expect(clientJs.content).toContain('.flatMap(')
-    expect(clientJs.content).toContain('.join(')
-    // JSX should be compiled to renderChild calls, not raw JSX
-    expect(clientJs.content).toContain("renderChild('ResizablePanel'")
-    expect(clientJs.content).toContain("renderChild('ResizableHandle'")
-    expect(clientJs.content).not.toContain('<ResizablePanel')
-    expect(clientJs.content).not.toContain('<ResizableHandle')
-  })
-})
-
-describe('.flatMap() — Hono adapter', () => {
-  test('Hono preserves JSX in flatMap callback', () => {
-    const source = `
-      'use client'
-
-      export function Timeline(props: { frames: { label: string }[] }) {
-        return (
-          <div>
-            {props.frames.flatMap((frame, i) => {
-              const panel = (
-                <ResizablePanel key={\`p-\${i}\`}>
-                  {i + 1}
-                </ResizablePanel>
-              )
-              if (i === 0) return [panel]
-              return [<ResizableHandle key={\`h-\${i}\`} />, panel]
-            })}
-          </div>
-        )
-      }
-    `
-    const result = compileJSX(source, 'Timeline.tsx', { adapter: new HonoAdapter() })
-    expect(result.errors).toHaveLength(0)
-
-    const markedTemplate = result.files.find(f => f.type === 'markedTemplate')!
-    // Hono should use flatMap (not map)
-    expect(markedTemplate.content).toContain('.flatMap(')
-    // Hono preserves JSX natively
-    expect(markedTemplate.content).toContain('<ResizablePanel')
-    expect(markedTemplate.content).toContain('<ResizableHandle')
-  })
-
-  test('simple flatMap arrow with array literal works in Hono', () => {
-    const source = `
-      'use client'
-
-      export function DL(props: { items: { term: string; def: string }[] }) {
-        return (
-          <dl>
-            {props.items.flatMap((item, i) => [
-              <dt key={\`dt-\${i}\`}>{item.term}</dt>,
-              <dd key={\`dd-\${i}\`}>{item.def}</dd>
-            ])}
-          </dl>
-        )
-      }
-    `
-    const result = compileJSX(source, 'DL.tsx', { adapter: new HonoAdapter() })
-    expect(result.errors).toHaveLength(0)
-
-    const markedTemplate = result.files.find(f => f.type === 'markedTemplate')!
-    expect(markedTemplate.content).toContain('.flatMap(')
-  })
-})
-
-describe('.flatMap() — single JSX return (same as map)', () => {
-  test('flatMap with single JSX return compiles like map', () => {
-    const source = `
-      'use client'
-
-      export function List(props: { items: string[] }) {
-        return (
-          <ul>
-            {props.items.flatMap((item, i) => (
-              <li key={i}>{item}</li>
-            ))}
-          </ul>
-        )
-      }
-    `
-    const result = compileJSX(source, 'List.tsx', { adapter })
-    expect(result.errors).toHaveLength(0)
-
-    const clientJs = result.files.find(f => f.type === 'clientJs')!
-    expect(clientJs.content).toContain('.flatMap(')
-    // Template contains compiled HTML template literal, not raw JSX
-    expect(clientJs.content).toContain('data-key')
-  })
-})
-
-describe('.flatMap() — variable-assigned result (#1554 comment)', () => {
-  test('flatMap stored in const, then used in JSX, compiles without raw JSX', () => {
-    const source = `
-      'use client'
-
-      export function TimelineBar(props: { items: string[] }) {
-        const children = props.items.flatMap((item, i) => {
-          const panel = (
-            <ResizablePanel key={item} defaultSize={50} className="segment">
-              <span>{i + 1}</span>
-            </ResizablePanel>
-          )
-          if (i === 0) return [panel]
-          return [<ResizableHandle key={\`h-\${item}\`} />, panel]
-        })
-
-        return (
-          <ResizablePanelGroup direction="horizontal">
-            {children}
-          </ResizablePanelGroup>
-        )
-      }
-    `
-    const result = compileJSX(source, 'TimelineBar.tsx', { adapter })
-    expect(result.errors).toHaveLength(0)
-
-    const clientJs = result.files.find(f => f.type === 'clientJs')!
-    // flatMap should be used (not map)
-    expect(clientJs.content).toContain('.flatMap(')
-    // JSX should be compiled to renderChild calls, not raw JSX
-    expect(clientJs.content).toContain("renderChild('ResizablePanel'")
-    expect(clientJs.content).toContain("renderChild('ResizableHandle'")
-    expect(clientJs.content).not.toContain('<ResizablePanel')
-    expect(clientJs.content).not.toContain('<ResizableHandle')
-    // The raw const declaration should not appear in the init function
-    expect(clientJs.content).not.toContain('const children = ')
-  })
-
-  test('map() stored in const with JSX also gets inlined', () => {
-    const source = `
-      'use client'
-
-      export function List(props: { items: string[] }) {
-        const rendered = props.items.map((item, i) => (
-          <ListItem key={i} label={item} />
-        ))
-
-        return (
-          <ul>{rendered}</ul>
-        )
-      }
-    `
-    const result = compileJSX(source, 'List.tsx', { adapter })
-    expect(result.errors).toHaveLength(0)
-
-    const clientJs = result.files.find(f => f.type === 'clientJs')!
-    expect(clientJs.content).not.toContain('<ListItem')
-    expect(clientJs.content).not.toContain('const rendered = ')
-  })
-})

package/src/__tests__/reduce-op.test.ts

@@ -1,201 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-import { parseExpression, isSupported, stringifyParsedExpr } from '../expression-parser'
-
-/**
- * `.reduce(fn, init)` arithmetic-fold catalogue (#1448 Tier C). The
- * parser intercepts the accepted shapes into a structured `ReduceOp`
- * (mirroring the `.sort` `SortComparator` precedent) and refuses
- * everything else to `unsupported` so the template adapters surface
- * BF101 with the `@client` escape hatch.
- */
-describe('reduce() arithmetic-fold catalogue', () => {
-  test('numeric sum over a field → field/numeric', () => {
-    const r = parseExpression('items.reduce((sum, t) => sum + t.duration, 0)')
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.op).toBe('+')
-      expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'duration' })
-      expect(r.reduceOp.type).toBe('numeric')
-      expect(r.reduceOp.init).toBe('0')
-      expect(r.reduceOp.paramAcc).toBe('sum')
-      expect(r.reduceOp.paramItem).toBe('t')
-    }
-    expect(isSupported(r).supported).toBe(true)
-  })
-
-  test('numeric sum over self (primitive array) → self/numeric', () => {
-    const r = parseExpression('nums.reduce((a, b) => a + b, 0)')
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.op).toBe('+')
-      expect(r.reduceOp.key).toEqual({ kind: 'self' })
-      expect(r.reduceOp.type).toBe('numeric')
-    }
-  })
-
-  test('reduceRight shares the catalogue and preserves the method name', () => {
-    const r = parseExpression("items.reduceRight((acc, x) => acc + x.label, '')")
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method') {
-      expect(r.method).toBe('reduceRight')
-      if (r.method === 'reduceRight') {
-        expect(r.reduceOp.op).toBe('+')
-        expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'label' })
-        expect(r.reduceOp.type).toBe('string')
-      }
-    }
-  })
-
-  test('reduceRight round-trips with its method name preserved', () => {
-    const r = parseExpression('nums.reduceRight((a, b) => a + b, 0)')
-    expect(stringifyParsedExpr(r)).toBe('nums.reduceRight((a,b) => a + b, 0)')
-  })
-
-  test('product over a field with init 1 → field/numeric/*', () => {
-    const r = parseExpression('items.reduce((acc, x) => acc * x.qty, 1)')
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.op).toBe('*')
-      expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'qty' })
-      expect(r.reduceOp.type).toBe('numeric')
-      expect(r.reduceOp.init).toBe('1')
-    }
-  })
-
-  test('string init makes + a concatenation fold (init is the decoded value)', () => {
-    const r = parseExpression("items.reduce((acc, x) => acc + x.label, '')")
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.op).toBe('+')
-      expect(r.reduceOp.type).toBe('string')
-      expect(r.reduceOp.init).toBe('') // decoded contents, not the `''` source
-    }
-  })
-
-  test('non-empty string seed decodes to its contents', () => {
-    const r = parseExpression("items.reduce((acc, x) => acc + x.label, ', ')")
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.init).toBe(', ')
-    }
-  })
-
-  test('numeric init normalises separators / radix to canonical decimal', () => {
-    // `.text` gives TS's canonical decimal so Go ParseFloat + Perl agree
-    // (#1728 review: raw `1_000` / `0x10` would mis-parse on Go).
-    for (const [src, expected] of [
-      ['1_000', '1000'],
-      ['0x10', '16'],
-      ['1e3', '1000'],
-    ] as const) {
-      const r = parseExpression(`nums.reduce((a, b) => a + b, ${src})`)
-      expect(r.kind).toBe('array-method')
-      if (r.kind === 'array-method' && r.method === 'reduce') {
-        expect(r.reduceOp.init).toBe(expected)
-      }
-    }
-  })
-
-  test('parenthesized numeric init is unwrapped and accepted', () => {
-    for (const [src, expected] of [
-      ['(0)', '0'],
-      ['(-1)', '-1'],
-    ] as const) {
-      const r = parseExpression(`nums.reduce((a, b) => a + b, ${src})`)
-      expect(r.kind).toBe('array-method')
-      if (r.kind === 'array-method' && r.method === 'reduce') {
-        expect(r.reduceOp.init).toBe(expected)
-      }
-    }
-  })
-
-  test('an escape-free seed containing an apostrophe is accepted (decoded contents kept)', () => {
-    // `"a'b"` is escape-free (decoded === raw inner), so it's accepted;
-    // the decoded value carries the apostrophe, which the Mojo emit
-    // single-quote-escapes.
-    const r = parseExpression(`items.reduce((acc, x) => acc + x.l, "a'b")`)
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.init).toBe("a'b")
-    }
-  })
-
-  test('single-return block body unwraps to the fold expression', () => {
-    const r = parseExpression('items.reduce((sum, t) => { return sum + t.n }, 0)')
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'n' })
-    }
-  })
-
-  test('negative numeric init is accepted', () => {
-    const r = parseExpression('nums.reduce((a, b) => a + b, -1)')
-    expect(r.kind).toBe('array-method')
-    if (r.kind === 'array-method' && r.method === 'reduce') {
-      expect(r.reduceOp.init).toBe('-1')
-    }
-  })
-
-  test('round-trips a numeric fold back to valid JS via stringifyParsedExpr', () => {
-    const r = parseExpression('items.reduce((sum, t) => sum + t.duration, 0)')
-    expect(stringifyParsedExpr(r)).toBe('items.reduce((sum,t) => sum + t.duration, 0)')
-  })
-
-  test('round-trips a string fold by re-quoting the decoded seed', () => {
-    const r = parseExpression("items.reduce((a, x) => a + x.l, ', ')")
-    // Decoded seed `, ` re-quoted via JSON.stringify → a valid JS string.
-    expect(stringifyParsedExpr(r)).toBe('items.reduce((a,x) => a + x.l, ", ")')
-  })
-
-  describe('refused shapes → unsupported (BF101)', () => {
-    test('missing initial value', () => {
-      // A no-init reduce isn't intercepted (it needs 2 args); it falls
-      // through to a generic `call` that the UNSUPPORTED_METHODS gate
-      // refuses — JS throws on an empty array here, so a template can't
-      // mirror it cleanly.
-      const r = parseExpression('items.reduce((sum, t) => sum + t.duration)')
-      expect(isSupported(r).supported).toBe(false)
-    })
-
-    test('string concat with * is rejected', () => {
-      const r = parseExpression("items.reduce((acc, x) => acc * x.label, '')")
-      expect(r.kind).toBe('unsupported')
-    })
-
-    test('accumulator on the right operand is rejected', () => {
-      const r = parseExpression('items.reduce((sum, t) => t.duration + sum, 0)')
-      expect(r.kind).toBe('unsupported')
-    })
-
-    test('non-literal init is rejected', () => {
-      const r = parseExpression('items.reduce((sum, t) => sum + t.n, start)')
-      expect(r.kind).toBe('unsupported')
-    })
-
-    test('object-building reducer is rejected', () => {
-      const r = parseExpression('items.reduce((acc, x) => ({ ...acc, [x.id]: x }), {})')
-      expect(r.kind).toBe('unsupported')
-    })
-
-    test('deep field access is rejected', () => {
-      const r = parseExpression('items.reduce((sum, t) => sum + t.a.b, 0)')
-      expect(r.kind).toBe('unsupported')
-    })
-
-    test('string seed carrying an escape is rejected (cross-adapter safety)', () => {
-      // A seed with an escape can't be guaranteed byte-equal across the
-      // Go-template / Perl string embeddings without per-target decoding,
-      // so it refuses to `unsupported` rather than risk divergence.
-      const r = parseExpression("items.reduce((acc, x) => acc + x.l, '\\n')")
-      expect(r.kind).toBe('unsupported')
-    })
-
-    test('reduceRight without an init is refused (like reduce)', () => {
-      // The matching 2-arg form is intercepted; a no-init reduceRight
-      // falls through to a generic call the UNSUPPORTED_METHODS gate
-      // refuses (JS throws on an empty array there).
-      const rr = parseExpression('items.reduceRight((sum, t) => sum + t.n)')
-      expect(isSupported(rr).supported).toBe(false)
-    })
-  })
-})