@barefootjs/jsx 0.5.3 → 0.6.1

package/src/__tests__/foreach-client-only.test.ts

@@ -0,0 +1,80 @@
+/**
+ * `.forEach()` is client-callback-only (#1448 Tier C / Tier D-class).
+ *
+ * `.forEach()` returns `undefined`, so it has no template-position meaning
+ * and is never a lowering target. This pins the two halves of that contract:
+ *
+ *  1. In **template position** the support gate refuses it (the template
+ *     adapters surface this as BF101 via `isSupported`), with a dedicated
+ *     reason that explains the `undefined` return — not the generic
+ *     `/* @client *​/` escape-hatch hint.
+ *  2. Inside an **event handler / `createEffect` callback** it is client JS
+ *     and passes straight through to the emitted runtime untouched — this is
+ *     the only valid use.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { parseExpression, isSupported } from '../expression-parser'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+describe('.forEach() — template position is refused (#1448)', () => {
+  test('isSupported reports forEach as unsupported', () => {
+    const support = isSupported(parseExpression('items().forEach(t => t.x)'))
+    expect(support.supported).toBe(false)
+    expect(support.level).toBe('L5_UNSUPPORTED')
+  })
+
+  test('refusal reason explains the undefined return and points to the valid uses', () => {
+    const support = isSupported(parseExpression('items().forEach(t => t.x)'))
+    expect(support.supported).toBe(false)
+    if (support.supported) return
+    // Dedicated forEach message that steers to .map(...) / createEffect —
+    // not the generic refusal, which offers the /* @client */ escape hatch.
+    expect(support.reason).toContain('returns undefined')
+    expect(support.reason).toContain('createEffect')
+    expect(support.reason).toContain('.map(')
+    expect(support.reason).not.toContain('/* @client */')
+  })
+
+  test('a bare-identifier receiver is refused too (not just signal getters)', () => {
+    const support = isSupported(parseExpression('list.forEach(x => x)'))
+    expect(support.supported).toBe(false)
+    expect(support.level).toBe('L5_UNSUPPORTED')
+  })
+})
+
+describe('.forEach() — client-callback use passes through (#1448)', () => {
+  // forEach inside an event handler and a createEffect callback is client JS;
+  // it must reach the emitted runtime verbatim with no compile error.
+  const source = `
+    'use client'
+    import { createSignal, createEffect } from '@barefootjs/client'
+
+    export function C() {
+      const [items, setItems] = createSignal<any[]>([])
+      const handle = () => { items().forEach(t => console.log(t)) }
+      createEffect(() => { items().forEach(t => t) })
+      return <button onClick={handle}>go</button>
+    }
+  `
+
+  test('no compile errors for forEach in callbacks', () => {
+    const result = compileJSX(source, 'C.tsx', { adapter })
+    expect(result.errors).toHaveLength(0)
+  })
+
+  test('forEach reaches the emitted client JS verbatim', () => {
+    const result = compileJSX(source, 'C.tsx', { adapter })
+    const client = result.files.find(f => f.path.endsWith('.client.js'))
+    expect(client).toBeDefined()
+    // Target the user's own `items().forEach(...)` calls specifically — a bare
+    // `/forEach/g` count would also catch any `forEach` the client-code
+    // generator emits for loop / hydration infrastructure, making this flaky.
+    // Both the handler call and the createEffect call must survive verbatim.
+    const occurrences = client!.content.match(/items\(\)\.forEach\(/g) ?? []
+    expect(occurrences.length).toBe(2)
+  })
+})

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__/ir-to-client-js/reactivity.test.ts

@@ -23,6 +23,7 @@ function makeContext(overrides: Partial<ClientJsContext> = {}): ClientJsContext
     loopElements: [],
     refElements: [],
     childInits: [],
+    deferredChildSlots: new Set(),
     reactiveProps: [],
     reactiveChildProps: [],
     reactiveAttrs: [],

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/__tests__/staged-ir/06-multi-stage-soak.test.ts

@@ -80,9 +80,24 @@ describe('Multi-stage soak (DeskCanvas-shape)', () => {
     expect(clientJs).toMatch(/import\s+\{[^}]*useYjs[^}]*\}\s+from\s+['"]\.\/useYjs['"]/)
   })
 
-  test('Module → Template: nodeTypes import IS visible to template', () => {
-    const { templateBody } = compile(DESK_CANVAS_SHAPE, 'DeskCanvas.tsx')
-    expect(templateBody).toMatch(/nodeTypes/)
+  test('Module → Init: nodeTypes is forwarded to the deferred child via init', () => {
+    // The `<Flow>` render carries init-scope-only props (`data-yjs={yjs.id}`
+    // where `yjs` is an init-local; `nodes={items()}`). The module-scope
+    // template lambda can't supply those, so the child render is DEFERRED
+    // to a `data-bf-ph` placeholder and `upsertChild` (→ createComponent)
+    // creates `Flow` with the COMPLETE getter props. The inlinable
+    // `nodeTypes` is therefore forwarded through the init `upsertChild`
+    // getter — never dropped — rather than baked into the template lambda.
+    // (Pre-fix this child was rendered eagerly via `renderChild('Flow', {
+    // nodeTypes })` with the init-scope props silently dropped — the
+    // dropped-prop bug.)
+    const { templateBody, initBody } = compile(DESK_CANVAS_SHAPE, 'DeskCanvas.tsx')
+    // Template defers the child render with a placeholder, not renderChild.
+    expect(templateBody).toMatch(/data-bf-ph="s0"/)
+    expect(templateBody).not.toMatch(/renderChild/)
+    // Init forwards nodeTypes (and every other prop) with complete values.
+    expect(initBody).toMatch(/upsertChild\(__scope,\s*'Flow',\s*'s0'/)
+    expect(initBody).toMatch(/get nodeTypes\(\)\s*\{\s*return nodeTypes\s*\}/)
   })
 
   // TODO(#1138 P3 5/N): `useYjs(...)` (init-local initializer) leaks into

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'
 
@@ -66,6 +66,13 @@ export type ArrayMethod =
   | 'toLowerCase'
   | 'toUpperCase'
   | 'trim'
+  | 'split'
+  | 'startsWith'
+  | 'endsWith'
+  | 'replace'
+  | 'repeat'
+  | 'padStart'
+  | 'padEnd'
 
 /**
  * Method names handled by the dedicated `sortMethod()` dispatcher
@@ -75,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'
 
 /**
@@ -133,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
 }
 
@@ -176,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)