@barefootjs/jsx 0.16.0 → 0.17.1

package/src/__tests__/serialize-parsed-expr.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, test } from 'bun:test'
+import { parseExpression, serializeParsedExpr, freeVarsInBody } from '../expression-parser'
+
+/**
+ * `serializeParsedExpr` emits the minimal JSON the runtime evaluator (Go
+ * `eval.go` `EvalNode` / Perl `Evaluator.pm` `evaluate`) reads. These tests pin
+ * the field contract (only evaluator-read fields per kind) and the purity gate
+ * (folded / non-expression kinds → null). `freeVarsInBody` pins the captured
+ * free-var set used to build the evaluator's `base_env`. (#2018)
+ */
+
+/** Parse a callback-body source and serialize it to the evaluator JSON object. */
+function evalJSON(src: string): unknown {
+  const s = serializeParsedExpr(parseExpression(src))
+  return s === null ? null : JSON.parse(s)
+}
+
+describe('serializeParsedExpr', () => {
+  test('literal carries only `value` (no literalType / raw)', () => {
+    expect(evalJSON('42')).toEqual({ kind: 'literal', value: 42 })
+    expect(evalJSON("'hi'")).toEqual({ kind: 'literal', value: 'hi' })
+    expect(evalJSON('true')).toEqual({ kind: 'literal', value: true })
+    expect(evalJSON('null')).toEqual({ kind: 'literal', value: null })
+  })
+
+  test('identifier carries `name`', () => {
+    expect(evalJSON('acc')).toEqual({ kind: 'identifier', name: 'acc' })
+  })
+
+  test('reducer body: binary over member projection', () => {
+    expect(evalJSON('acc + item.price')).toEqual({
+      kind: 'binary',
+      op: '+',
+      left: { kind: 'identifier', name: 'acc' },
+      // member carries object + property only (no `computed`).
+      right: {
+        kind: 'member',
+        object: { kind: 'identifier', name: 'item' },
+        property: 'price',
+      },
+    })
+  })
+
+  test('comparator body: 3-way ternary', () => {
+    expect(evalJSON('a > b ? 1 : a < b ? -1 : 0')).toEqual({
+      kind: 'conditional',
+      test: { kind: 'binary', op: '>', left: { kind: 'identifier', name: 'a' }, right: { kind: 'identifier', name: 'b' } },
+      consequent: { kind: 'literal', value: 1 },
+      alternate: {
+        kind: 'conditional',
+        test: { kind: 'binary', op: '<', left: { kind: 'identifier', name: 'a' }, right: { kind: 'identifier', name: 'b' } },
+        consequent: { kind: 'unary', op: '-', argument: { kind: 'literal', value: 1 } },
+        alternate: { kind: 'literal', value: 0 },
+      },
+    })
+  })
+
+  test('filter body: logical over member access', () => {
+    expect(evalJSON('item.done && item.priority > 3')).toEqual({
+      kind: 'logical',
+      op: '&&',
+      left: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'done' },
+      right: {
+        kind: 'binary',
+        op: '>',
+        left: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'priority' },
+        right: { kind: 'literal', value: 3 },
+      },
+    })
+  })
+
+  test('index-access carries object + index', () => {
+    expect(evalJSON('item[i]')).toEqual({
+      kind: 'index-access',
+      object: { kind: 'identifier', name: 'item' },
+      index: { kind: 'identifier', name: 'i' },
+    })
+  })
+
+  test('builtin call carries callee + args', () => {
+    expect(evalJSON('Math.max(a, b)')).toEqual({
+      kind: 'call',
+      callee: { kind: 'member', object: { kind: 'identifier', name: 'Math' }, property: 'max' },
+      args: [
+        { kind: 'identifier', name: 'a' },
+        { kind: 'identifier', name: 'b' },
+      ],
+    })
+  })
+
+  test('template literal: string + expression parts', () => {
+    expect(evalJSON('`n=${acc + 1}`')).toEqual({
+      kind: 'template-literal',
+      parts: [
+        { type: 'string', value: 'n=' },
+        { type: 'expression', expr: { kind: 'binary', op: '+', left: { kind: 'identifier', name: 'acc' }, right: { kind: 'literal', value: 1 } } },
+      ],
+    })
+  })
+
+  test('map body: object literal carries key + value (no keyKind / shorthand)', () => {
+    expect(evalJSON('({ id: item.id, n: item.n })')).toEqual({
+      kind: 'object-literal',
+      properties: [
+        { key: 'id', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'id' } },
+        { key: 'n', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'n' } },
+      ],
+    })
+  })
+
+  test('array literal', () => {
+    expect(evalJSON('[item.a, item.b]')).toEqual({
+      kind: 'array-literal',
+      elements: [
+        { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'a' },
+        { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'b' },
+      ],
+    })
+  })
+
+  test('purity gate: a folded method call in the body → null', () => {
+    // `.toUpperCase()` folds to `array-method`, outside the evaluator surface.
+    expect(serializeParsedExpr(parseExpression('item.name.toUpperCase()'))).toBeNull()
+    // A higher-order call (`.filter`) likewise.
+    expect(serializeParsedExpr(parseExpression('item.tags.filter(t => t)'))).toBeNull()
+    // An unsupported shape.
+    expect(serializeParsedExpr(parseExpression('a instanceof B'))).toBeNull()
+  })
+
+  test('purity gate: a folded subtree anywhere poisons the whole body', () => {
+    expect(serializeParsedExpr(parseExpression('acc + item.name.toUpperCase()'))).toBeNull()
+  })
+
+  test('purity gate: a non-builtin call is refused (evaluator would read it as nil)', () => {
+    // Bare function call — not on the evaluator allowlist.
+    expect(serializeParsedExpr(parseExpression('foo(item)'))).toBeNull()
+    // Method call on a value — generic `call` with a non-Math member callee.
+    expect(serializeParsedExpr(parseExpression('item.compute(2)'))).toBeNull()
+    // `parseInt` etc. are not the allowlisted `Number`/`String`/`Boolean`.
+    expect(serializeParsedExpr(parseExpression('parseInt(item.s)'))).toBeNull()
+    // A computed builtin reference the evaluator rejects (`Math['max']`).
+    expect(serializeParsedExpr(parseExpression("Math['max'](a, b)"))).toBeNull()
+  })
+
+  test('allowlisted builtins serialize (Math.* / String / Number / Boolean)', () => {
+    expect(serializeParsedExpr(parseExpression('Math.floor(item.x)'))).not.toBeNull()
+    expect(serializeParsedExpr(parseExpression('String(item.n)'))).not.toBeNull()
+    expect(serializeParsedExpr(parseExpression('Number(item.s)'))).not.toBeNull()
+    expect(serializeParsedExpr(parseExpression('Boolean(item.s)'))).not.toBeNull()
+  })
+
+  test('`.includes(x)` array-method serializes (the one array-method the evaluator executes)', () => {
+    expect(evalJSON("item.tags.includes('go')")).toEqual({
+      kind: 'array-method',
+      method: 'includes',
+      object: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'tags' },
+      args: [{ kind: 'literal', value: 'go' }],
+    })
+  })
+
+  test('every other array-method still folds outside the evaluator surface', () => {
+    expect(serializeParsedExpr(parseExpression('item.tags.join(",")'))).toBeNull()
+    expect(serializeParsedExpr(parseExpression('item.tags.slice(0, 1)'))).toBeNull()
+  })
+
+  test('a computed member value carries `computed: true` (plain access omits it)', () => {
+    // `row['price']` folds to a computed `member`; the flag is preserved so a
+    // computed member stays distinguishable. (`row.price` carries no `computed`.)
+    expect(evalJSON("row['price']")).toEqual({
+      kind: 'member',
+      object: { kind: 'identifier', name: 'row' },
+      property: 'price',
+      computed: true,
+    })
+    expect(evalJSON('row.price')).toEqual({
+      kind: 'member',
+      object: { kind: 'identifier', name: 'row' },
+      property: 'price',
+    })
+  })
+})
+
+describe('freeVarsInBody', () => {
+  test('collects refs minus the callback params, sorted & deduped', () => {
+    const body = parseExpression('acc + item.price + acc')
+    expect(freeVarsInBody(body, new Set(['acc', 'item']))).toEqual([])
+    expect(freeVarsInBody(body, new Set(['acc']))).toEqual(['item'])
+    expect(freeVarsInBody(body, new Set())).toEqual(['acc', 'item'])
+  })
+
+  test('captures an outer free var referenced in the body (base_env source)', () => {
+    // `taxRate` is neither param — it must travel as a captured free var.
+    const body = parseExpression('acc + item.price * taxRate')
+    expect(freeVarsInBody(body, new Set(['acc', 'item']))).toEqual(['taxRate'])
+  })
+
+  test('member property names are not references; object-literal values are', () => {
+    // `price` (property) is not a free var; `item` and `factor` are.
+    const body = parseExpression('({ total: item.price * factor })')
+    expect(freeVarsInBody(body, new Set()).sort()).toEqual(['factor', 'item'])
+  })
+
+  test('template + index + call cover their value positions', () => {
+    // `Math` is a builtin callee resolved syntactically by the evaluator — it
+    // is NOT captured (it would emit an undefined `$Math` / `.Math` base_env
+    // entry). The real refs `k`, `n`, `row` are.
+    const body = parseExpression('`${row[k]}-${Math.abs(n)}`')
+    expect(freeVarsInBody(body, new Set())).toEqual(['k', 'n', 'row'])
+  })
+
+  test('builtin call callees (Math.<fn> / String / Number / Boolean) are not captured', () => {
+    // Each builtin is resolved syntactically by the evaluator, so its
+    // identifier must not enter base_env (Copilot review #2031). The
+    // arguments, however, ARE real references.
+    const body = parseExpression('Math.max(a, factor) + Number(label) + String(x) + Boolean(flag)')
+    expect(freeVarsInBody(body, new Set(['a']))).toEqual(['factor', 'flag', 'label', 'x'])
+  })
+
+  test('`.includes(x)` array-method: both the receiver and the needle are free vars', () => {
+    const body = parseExpression('!tag || p.tags.includes(tag)')
+    expect(freeVarsInBody(body, new Set())).toEqual(['p', 'tag'])
+  })
+})

package/src/__tests__/ssr-seed-plan.test.ts

@@ -0,0 +1,212 @@
+// Backend-neutral SSR seed plan (`computeSsrSeedPlan`, attached to
+// `IRMetadata.ssrSeedPlan` by `buildMetadata`). The plan ports the
+// derived/opaque/env-reader scope analysis the template adapters' seed paths
+// perform, so these tests pin the decision rules against metadata built by
+// the real pipeline (`analyzeComponent` + `buildMetadata`).
+
+import { describe, test, expect } from 'bun:test'
+import { analyzeComponent } from '../analyzer'
+import { buildMetadata } from '../compiler'
+import type { SsrSeedPlan, SsrSeedStep } from '../ssr-seed-plan'
+
+function planFor(source: string, componentName?: string): SsrSeedPlan {
+  const ctx = analyzeComponent(source, 'test.tsx', componentName)
+  const plan = buildMetadata(ctx).ssrSeedPlan
+  expect(plan).toBeDefined()
+  return plan!
+}
+
+function step(plan: SsrSeedPlan, name: string): SsrSeedStep {
+  const found = plan.steps.find(s => s.name === name)
+  expect(found).toBeDefined()
+  return found!
+}
+
+describe('computeSsrSeedPlan', () => {
+  test('env signal (aliased) → env-reader step; derived memo over it', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSearchParams } from '@barefootjs/client'
+      function List() {
+        const [sp] = createSearchParams()
+        const sort = createMemo(() => sp().get('sort') ?? 'date')
+        return <p>{sort()}</p>
+      }
+    `)
+
+    const sp = step(plan, 'sp')
+    expect(sp.kind).toBe('env-reader')
+    if (sp.kind === 'env-reader') {
+      expect(sp.reader.canonicalName).toBe('searchParams')
+      expect(sp.reader.key).toBe('search')
+    }
+
+    const sort = step(plan, 'sort')
+    expect(sort.kind).toBe('derived')
+    if (sort.kind === 'derived') {
+      expect(sort.origin).toBe('memo')
+      expect(sort.frees).toEqual(['sp'])
+      expect(sort.expr).toBe("sp().get('sort') ?? 'date'")
+      expect(sort.parsed).toBeDefined()
+    }
+  })
+
+  test('chained memos in a props-object component: declaration order, scope accumulates', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSearchParams } from '@barefootjs/client'
+      function List(props: { items: { tag: string; name: string }[] }) {
+        const [sp] = createSearchParams()
+        const tag = createMemo(() => sp().get('tag') ?? '')
+        const visible = createMemo(() => props.items.filter((p) => p.tag === tag()))
+        return <ul>{visible().map((i) => <li>{i.name}</li>)}</ul>
+      }
+    `)
+
+    expect(plan.baseScope).toContain('props')
+    expect(plan.steps.map(s => s.name)).toEqual(['sp', 'tag', 'visible'])
+
+    expect(step(plan, 'tag').kind).toBe('derived')
+    const visible = step(plan, 'visible')
+    expect(visible.kind).toBe('derived')
+    if (visible.kind === 'derived') {
+      for (const free of visible.frees) {
+        expect(['props', 'tag']).toContain(free)
+      }
+    }
+  })
+
+  test('forward reference to a later memo → opaque; the later memo itself is derived', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      function C() {
+        const [n, setN] = createSignal(1)
+        const early = createMemo(() => late() + 1)
+        const late = createMemo(() => n() * 2)
+        return <p>{early()}</p>
+      }
+    `)
+
+    expect(step(plan, 'early').kind).toBe('opaque')
+    expect(step(plan, 'late').kind).toBe('derived')
+  })
+
+  test('self reference → opaque (name enters scope only after its own step)', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      function C() {
+        const loop = createMemo(() => loop())
+        return <p>{loop()}</p>
+      }
+    `)
+
+    expect(step(plan, 'loop').kind).toBe('opaque')
+  })
+
+  test('shadowed callback param leaking as an outer free identifier → opaque', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      function C(props: { items: { ok: boolean }[] }) {
+        const bad = createMemo(() => props.items.filter((p) => p.ok) && p)
+        return <p>{bad()}</p>
+      }
+    `)
+
+    expect(step(plan, 'bad').kind).toBe('opaque')
+  })
+
+  test('module string const counts as base scope; memo referencing it is derived', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      const activeCls = 'text-bold'
+      function C() {
+        const [on, setOn] = createSignal(false)
+        const cls = createMemo(() => on() ? activeCls : 'text-dim')
+        return <p class={cls()}>x</p>
+      }
+    `, 'C')
+
+    expect(plan.baseScope).toContain('activeCls')
+    const cls = step(plan, 'cls')
+    expect(cls.kind).toBe('derived')
+    if (cls.kind === 'derived') {
+      expect(cls.frees).toContain('on')
+      expect(cls.frees).toContain('activeCls')
+    }
+  })
+
+  test('block-bodied memo → opaque (v1 gates to expression-bodied memos)', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      function C() {
+        const [on, setOn] = createSignal(false)
+        const label = createMemo(() => {
+          const v = on()
+          return v ? 'yes' : 'no'
+        })
+        return <p>{label()}</p>
+      }
+    `)
+
+    const label = step(plan, 'label')
+    expect(label.kind).toBe('opaque')
+    if (label.kind === 'opaque') expect(label.origin).toBe('memo')
+  })
+
+  test('unsupported body (object literal) → opaque', () => {
+    const plan = planFor(`
+      'use client'
+      import { createMemo, createSignal } from '@barefootjs/client'
+      function C() {
+        const [n, setN] = createSignal(1)
+        const obj = createMemo(() => ({ value: n() }))
+        return <p>{obj().value}</p>
+      }
+    `)
+
+    expect(step(plan, 'obj').kind).toBe('opaque')
+  })
+
+  test('literal signal init → derived with empty frees (constant-skip is emit-side)', () => {
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [v, setV] = createSignal('b')
+        return <p>{v()}</p>
+      }
+    `)
+
+    const v = step(plan, 'v')
+    expect(v.kind).toBe('derived')
+    if (v.kind === 'derived') {
+      expect(v.origin).toBe('signal')
+      expect(v.frees).toEqual([])
+      expect(v.expr).toBe("'b'")
+    }
+  })
+
+  test('prop-derived signal init → derived with the prop free', () => {
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Toggle(props: { defaultOn?: boolean }) {
+        const [on, setOn] = createSignal(props.defaultOn ?? false)
+        return <button aria-pressed={on()}>t</button>
+      }
+    `)
+
+    expect(plan.baseScope).toContain('props')
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('derived')
+    if (on.kind === 'derived') {
+      expect(on.origin).toBe('signal')
+      expect(on.frees).toEqual(['props'])
+    }
+  })
+})

package/src/__tests__/unsupported-expression.test.ts

@@ -216,10 +216,11 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     expect(bf021[0].message).toContain('not a supported shape')
   })
 
-  test('emits BF021 error for multi-statement block-body sort comparator', () => {
-    // Single-`return` block bodies now lower (#1448 Tier B follow-up),
-    // but multi-statement / local-var bodies stay refused — generalising
-    // over arbitrary statement sequences isn't tractable in a template.
+  test('no BF021 for let-inline block-body sort comparator (#2040)', () => {
+    // #2040: a value-producing block body (pure `const` bindings + a terminal
+    // `return`) normalises to a single expression via let-inline, so a
+    // `{ const x = a.price; return x - b.price }` comparator now lowers exactly
+    // like the expression-bodied `(a, b) => a.price - b.price`.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -239,6 +240,32 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     const { errors } = compileToIR(source)
     const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
 
+    expect(bf021).toHaveLength(0)
+  })
+
+  test('emits BF021 error for imperative block-body sort comparator (#2040)', () => {
+    // An imperative comparator (local re-assignment / mutation) has no
+    // value-position lowering — `foldBlockToExpr` refuses it, so the arrow stays
+    // `unsupported` and the sort extraction surfaces BF021.
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        return (
+          <ul>
+            {items().sort((a, b) => { let r = 0; r = a.price - b.price; return r }).map(t => (
+              <li>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
     expect(bf021).toHaveLength(1)
     expect(bf021[0].message).toContain('not a supported shape')
   })
@@ -583,3 +610,70 @@ describe('Rest Pattern in Filter Predicate (BF021, #1532)', () => {
     expect(bf021).toHaveLength(0)
   })
 })
+
+// Block-bodied filter predicates are normalized to a single boolean expression
+// (#2040). A value-producing block lowers like an expression predicate; an
+// imperative block refuses.
+describe('Block-body filter predicate normalization (#2040)', () => {
+  function loopFilterIR(predicate: string) {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        const [filter, setFilter] = createSignal('all')
+        return (
+          <ul>
+            {items().filter(${predicate}).map(t => (
+              <li>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+    const { ir, errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+    // Find the loop node carrying the filterPredicate.
+    let found: any = null
+    const walk = (n: any) => {
+      if (!n || found) return
+      if (n.filterPredicate) found = n
+      for (const c of n.children ?? []) walk(c)
+    }
+    walk(ir)
+    return { bf021, filterPredicate: found?.filterPredicate }
+  }
+
+  test('value-producing block (let-inline + early return) folds to a predicate', () => {
+    const { bf021, filterPredicate } = loopFilterIR(`t => {
+      const f = filter()
+      if (f === 'active') return !t.done
+      if (f === 'completed') return t.done
+      return true
+    }`)
+    expect(bf021).toHaveLength(0)
+    // No leftover block shape — a single boolean predicate expression.
+    expect(filterPredicate?.predicate).toBeDefined()
+    expect((filterPredicate as any)?.blockBody).toBeUndefined()
+  })
+
+  test('signal read on multiple branches still folds (idempotent getter is pure)', () => {
+    const { bf021, filterPredicate } = loopFilterIR(`t => {
+      const f = filter()
+      if (f === 'active') return !t.done
+      return f === 'completed' ? t.done : true
+    }`)
+    expect(bf021).toHaveLength(0)
+    expect(filterPredicate?.predicate).toBeDefined()
+  })
+
+  test('imperative block (local re-assignment) refuses with BF021', () => {
+    const { bf021 } = loopFilterIR(`t => {
+      let keep = false
+      keep = !t.done
+      return keep
+    }`)
+    expect(bf021.length).toBeGreaterThan(0)
+  })
+})