@barefootjs/jsx 0.6.0 → 0.7.0

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

@@ -0,0 +1,104 @@
+/**
+ * Pins the `IRComponent.dynamicTag` flag — the additive signal the Go
+ * template adapter uses to lower a runtime-chosen tag (`const Tag =
+ * children.tag`) to a children passthrough instead of an impossible
+ * `{{template "Tag" ...}}` call.
+ *
+ * Background: the `Slot` component does
+ *   `const Tag = children.tag; return <Tag {...}>{...}</Tag>`
+ * The compiler treats `<Tag>` as a PascalCase component reference, so a
+ * naive Go lowering emits `{{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"`. `dynamicTag` lets the Go adapter detect
+ * and defuse this; Hono/CSR/Mojo ignore the flag.
+ *
+ * The binding lives inside an `if (isValidElement(children)) { … }`
+ * block, so detection must scan nested scopes (not just component-body
+ * `localConstants`). These tests pin both that positive detection and
+ * the negative case — a real imported `<Button>` must NOT be flagged.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+import type { IRNode, IRComponent } from '../types'
+
+const adapter = new TestAdapter()
+
+function compileToIR(source: string) {
+  const result = compileJSX(source, 'demo.tsx', { adapter, outputIR: true })
+  expect(result.errors.filter(e => e.severity === 'error')).toEqual([])
+  const ir = result.files.find(f => f.type === 'ir')!
+  return JSON.parse(ir.content)
+}
+
+function findComponent(node: IRNode, name: string): IRComponent | null {
+  if (node.type === 'component' && (node as IRComponent).name === name) {
+    return node as IRComponent
+  }
+  const anyNode = node as IRNode & {
+    children?: IRNode[]
+    consequent?: IRNode
+    alternate?: IRNode
+    then?: IRNode
+    else?: IRNode
+  }
+  for (const key of ['children', 'consequent', 'alternate', 'then', 'else'] as const) {
+    const v = anyNode[key]
+    if (!v) continue
+    const list = Array.isArray(v) ? v : [v]
+    for (const c of list) {
+      const found = findComponent(c, name)
+      if (found) return found
+    }
+  }
+  return null
+}
+
+describe('IRComponent.dynamicTag', () => {
+  test('a block-scoped `const Tag = children.tag` JSX tag is flagged dynamicTag', () => {
+    const ir = compileToIR(`
+function isValidElement(el: unknown): el is { tag: unknown; props: Record<string, unknown> } {
+  return !!(el && typeof el === 'object' && 'tag' in el && 'props' in el)
+}
+export function Slot({ children, className, ...props }: { children?: any; className?: string; [k: string]: unknown }) {
+  if (children && isValidElement(children)) {
+    const Tag = children.tag as any
+    const childProps = children.props
+    return <Tag {...childProps} {...props} className={className}>{childProps.children}</Tag>
+  }
+  return <>{children}</>
+}
+`)
+    const tag = findComponent(ir.root, 'Tag')
+    expect(tag).not.toBeNull()
+    expect(tag!.dynamicTag).toBe(true)
+  })
+
+  test('a real imported component is NOT flagged dynamicTag', () => {
+    const ir = compileToIR(`
+import { Button } from './button'
+export function Demo() {
+  return <Button>hi</Button>
+}
+`)
+    const button = findComponent(ir.root, 'Button')
+    expect(button).not.toBeNull()
+    expect(button!.dynamicTag).toBeUndefined()
+  })
+
+  test('a local JSX-producing const factory is NOT flagged dynamicTag', () => {
+    const ir = compileToIR(`
+export function Demo() {
+  const Inner = () => <span>x</span>
+  return <div><Inner /></div>
+}
+`)
+    const inner = findComponent(ir.root, 'Inner')
+    // Local component factories lower via the jsx* inlining paths; whether
+    // they survive as an IRComponent node or get inlined, they must never
+    // carry the dynamicTag flag (their initializer is an arrow, not `.tag`).
+    if (inner) expect(inner.dynamicTag).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,51 @@
+import { describe, test, expect } from 'bun:test'
+import { analyzeComponent } from '../analyzer'
+import { jsxToIR } from '../jsx-to-ir'
+import { parseExpression } from '../expression-parser'
+
+/**
+ * IR-level verification for `.reduce(fn, init)` (#1448 Tier C). The
+ * parser intercepts the arithmetic-fold catalogue into a structured
+ * `array-method` + `ReduceOp` node — this test pins the source-string
+ * that survives through `jsxToIR` to an `IRExpression`, then re-parses
+ * it to confirm the structured fold shape adapters consume.
+ *
+ * Hydration and template-emit correctness are pinned at the adapter
+ * conformance layer (`reduce-*` fixtures in `packages/adapter-tests/
+ * fixtures/methods/`).
+ */
+describe('reduce(fn, init) IR shape', () => {
+  test('sum over a struct field re-parses to a numeric ReduceOp', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function Total() {
+        const [items] = createSignal<{ duration: number }[]>([])
+        return <div>{items().reduce((sum, t) => sum + t.duration, 0)}</div>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Total.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type !== 'element') return
+    const exprNode = ir!.children.find(c => c.type === 'expression')
+    expect(exprNode?.type).toBe('expression')
+    if (exprNode?.type !== 'expression') return
+
+    // The IR carries the expression as a source string (the same shape
+    // adapters re-parse at emit time). Round-trip it to confirm the
+    // ReduceOp catalogue match survives the analyzer → IR boundary.
+    const parsed = parseExpression(exprNode.expr)
+    expect(parsed.kind).toBe('array-method')
+    if (parsed.kind !== 'array-method') return
+    expect(parsed.method).toBe('reduce')
+    if (parsed.method !== 'reduce') return
+    expect(parsed.reduceOp.op).toBe('+')
+    expect(parsed.reduceOp.key).toEqual({ kind: 'field', field: 'duration' })
+    expect(parsed.reduceOp.type).toBe('numeric')
+    expect(parsed.reduceOp.init).toBe('0')
+  })
+})

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

@@ -0,0 +1,201 @@
+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)
+    })
+  })
+})

package/src/adapters/parsed-expr-emitter.ts

@@ -33,7 +33,7 @@
  *     be added in one place.
  */
 
-import type { ParsedExpr, SortComparator, TemplatePart } from '../expression-parser'
+import type { ParsedExpr, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '../expression-parser'
 
 export type HigherOrderMethod = 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'
 
@@ -82,6 +82,17 @@ export type ArrayMethod =
  */
 export type SortMethod = 'sort' | 'toSorted'
 
+/**
+ * `reduce` / `reduceRight` are handled by the dedicated `reduceMethod()`
+ * dispatcher arm (#1448 Tier C) for the same reason sort is: they carry
+ * a structured `ReduceOp` (the parsed arithmetic-fold spec) rather than
+ * a `ParsedExpr[]` args list, so folding them into `arrayMethod()` would
+ * force a spec-or-args runtime check at every call site. The method name
+ * is threaded through so adapters can pick the fold direction (left for
+ * `reduce`, right for `reduceRight`).
+ */
+export type ReduceMethod = 'reduce' | 'reduceRight'
+
 export type LiteralType = 'string' | 'number' | 'boolean' | 'null'
 
 /**
@@ -140,6 +151,28 @@ export interface ParsedExprEmitter {
     comparator: SortComparator,
     emit: (e: ParsedExpr) => string,
   ): string
+  reduceMethod(
+    method: ReduceMethod,
+    object: ParsedExpr,
+    reduceOp: ReduceOp,
+    emit: (e: ParsedExpr) => string,
+  ): string
+  // `.flat(depth?)` gets its own dispatcher arm (#1448 Tier C): it carries
+  // a structured `FlatDepth` (the validated literal / `'infinity'`) rather
+  // than a `ParsedExpr[]` args list, same rationale as sort / reduce.
+  flatMethod(
+    object: ParsedExpr,
+    depth: FlatDepth,
+    emit: (e: ParsedExpr) => string,
+  ): string
+  // `.flatMap(fn)` value-returning field projection gets its own arm
+  // (#1448 Tier C): it carries a structured `FlatMapOp` rather than a
+  // `ParsedExpr[]` args list, same rationale as sort / reduce / flat.
+  flatMapMethod(
+    object: ParsedExpr,
+    op: FlatMapOp,
+    emit: (e: ParsedExpr) => string,
+  ): string
   unsupported(raw: string, reason: string): string
 }
 
@@ -183,6 +216,15 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       if (expr.method === 'sort' || expr.method === 'toSorted') {
         return emitter.sortMethod(expr.method, expr.object, expr.comparator, emit)
       }
+      if (expr.method === 'reduce' || expr.method === 'reduceRight') {
+        return emitter.reduceMethod(expr.method, expr.object, expr.reduceOp, emit)
+      }
+      if (expr.method === 'flat') {
+        return emitter.flatMethod(expr.object, expr.flatDepth, emit)
+      }
+      if (expr.method === 'flatMap') {
+        return emitter.flatMapMethod(expr.object, expr.flatMapOp, emit)
+      }
       return emitter.arrayMethod(expr.method, expr.object, expr.args, emit)
     case 'unsupported':
       return emitter.unsupported(expr.raw, expr.reason)