@barefootjs/jsx 0.32.0 → 0.33.1

package/src/__tests__/ssr-defaults.test.ts

@@ -458,6 +458,47 @@ describe('extractSsrDefaults', () => {
     // space mirrors Hono's empty-className interpolation).
     expect(defaults?.classes).toEqual({ value: 'a b c d  tail' })
   })
+
+  // #2698 review: a property access on a non-plain-object base (an array
+  // element bound by `.map()`) must refuse (UNRESOLVED), not silently read
+  // `undefined` via `hasOwnProperty` — an array exposes prototype members
+  // (`.map`, `.filter`, …) that aren't own properties, so the old guard
+  // (`typeof !== 'object'`) let arrays through and misreported them as a
+  // real `undefined` value instead of an unrepresentable read.
+  test('.map() body property-access on an ARRAY element is UNRESOLVED, not undefined', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [x] = createSignal([[1, 2], [3, 4]].map(t => t.foo))
+        return <p>{x()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    // UNRESOLVED aborts the whole `.map()` (not a per-element `null`) —
+    // resultToJsonable renders the abort as the same `null` a genuinely
+    // undefined value would, but the two paths reach it differently: this
+    // pin exists to keep the array case going through the abort path.
+    expect(defaults?.x).toEqual({ value: null })
+  })
+
+  test('.map() body property-access on a PLAIN-OBJECT element still resolves a missing key to undefined', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [x] = createSignal([{ a: 1 }, {}].map(t => t.a))
+        return <p>{x()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    // Unlike the array case, a missing key on a plain object resolves that
+    // ONE element to `undefined` (→ `null`) and the `.map()` keeps going —
+    // it does not abort the whole computation.
+    expect(defaults?.x).toEqual({ value: [1, null] })
+  })
 })
 
 // TS twin of the Ruby/Python/PHP/Perl/Rust `derive*FromDefaults` runtime

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

@@ -158,7 +158,12 @@ describe('computeSsrSeedPlan', () => {
     if (label.kind === 'opaque') expect(label.origin).toBe('memo')
   })
 
-  test('unsupported body (object literal) → opaque', () => {
+  test('object-literal body → derived (#2696: value-position object literal, isSupportedValue)', () => {
+    // Was `opaque` before `checkSupport` gained its `pos` parameter — a
+    // memo's WHOLE body is a value position (an assignment, never a
+    // render), so an object literal there is exactly the shape
+    // `isSupportedValue` now admits (every property value — here `n()` —
+    // is itself supported).
     const plan = planFor(`
       'use client'
       import { createMemo, createSignal } from '@barefootjs/client'
@@ -169,7 +174,12 @@ describe('computeSsrSeedPlan', () => {
       }
     `)
 
-    expect(step(plan, 'obj').kind).toBe('opaque')
+    const obj = step(plan, 'obj')
+    expect(obj.kind).toBe('derived')
+    if (obj.kind === 'derived') {
+      expect(obj.origin).toBe('memo')
+      expect(obj.frees).toEqual(['n'])
+    }
   })
 
   test('literal signal init → derived with empty frees (constant-skip is emit-side)', () => {

package/src/adapters/dangerous-inner-html.ts

@@ -122,6 +122,7 @@ function htmlPropValue(parsed: ParsedExpr): ParsedExpr | null {
   if (parsed.kind !== 'object-literal') return null
   if (parsed.properties.length !== 1) return null
   const [prop] = parsed.properties
+  if (prop.kind === 'spread') return null
   if (prop.key !== '__html') return null
   return prop.value
 }

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

@@ -163,9 +163,11 @@ export interface ParsedExprEmitter {
   arrow(params: string[], body: ParsedExpr, emit: (e: ParsedExpr) => string): string
   regex(raw: string): string
   arrayLiteral(elements: ParsedExpr[], emit: (e: ParsedExpr) => string): string
-  // Emit an object literal `{ a: 1, b: x }`. `raw` is the original
-  // expression string so an adapter that doesn't lower object values yet
-  // can delegate to `unsupported(raw, …)` and stay byte-identical.
+  // Emit an object literal `{ a: 1, b: x, ...rest }` (#2696 Step 2 adds
+  // spread entries — `properties` is ORDER-PRESERVING, so an adapter must
+  // merge left-to-right, later entries winning, to match JS). `raw` is the
+  // original expression string so an adapter that doesn't lower object
+  // values yet can delegate to `unsupported(raw, …)` and stay byte-identical.
   objectLiteral(
     properties: ObjectLiteralProperty[],
     raw: string,
@@ -277,6 +279,50 @@ export function groupBinaryOperand(operand: ParsedExpr, emitted: string): string
     : emitted
 }
 
+/**
+ * Split an `object-literal`'s (order-preserving) `properties` into rendered
+ * SEGMENTS an adapter's `objectLiteral()` folds with its own merge idiom
+ * (#2696 Step 2): each maximal run of consecutive `prop` entries collapses
+ * into ONE literal (via `literalOf`), and each `spread` entry becomes its
+ * own segment (its emitted source expression) — so `{ a: 1, b: 2, ...t, c: 3
+ * }` yields `[literal({a,b}), emit(t), literal({c})]`, in source order.
+ *
+ * A caller with NO spread entries at all should keep its pre-#2696 single
+ * `literalOf(properties)` call instead of this (this always returns at
+ * least one segment, but a caller folding 1-segment output through a merge
+ * call — `array_merge(x)`, `{}.merge(x)` — would be needlessly indirect
+ * for the common spread-free case).
+ *
+ * Shared here (not duplicated per adapter) because the grouping itself is
+ * backend-neutral structure — only `literalOf` (the target language's
+ * literal syntax) and the fold (the target language's merge idiom) are
+ * adapter-specific.
+ */
+export function groupObjectLiteralSegments(
+  properties: readonly ObjectLiteralProperty[],
+  literalOf: (run: ReadonlyArray<Extract<ObjectLiteralProperty, { kind: 'prop' }>>) => string,
+  emit: (e: ParsedExpr) => string,
+): string[] {
+  const segments: string[] = []
+  let run: Extract<ObjectLiteralProperty, { kind: 'prop' }>[] = []
+  const flushRun = () => {
+    if (run.length > 0) {
+      segments.push(literalOf(run))
+      run = []
+    }
+  }
+  for (const p of properties) {
+    if (p.kind === 'spread') {
+      flushRun()
+      segments.push(emit(p.expr))
+    } else {
+      run.push(p)
+    }
+  }
+  flushRun()
+  return segments
+}
+
 /**
  * Single point of dispatch from `ParsedExpr.kind` to the adapter's
  * method. Adapters call this once at their entry point; the recursion

package/src/analyzer.ts

@@ -796,6 +796,29 @@ function visitComponentBody(node: ts.Node, ctx: AnalyzerContext): void {
       (ts.isBlock(node) && node.parent === ctx.componentBodyBlock)
     )
   ) {
+    // #2720: a bare top-level block whose ONLY job is naming the render
+    // value before returning it (`{ const __root = <jsx/>; return __root
+    // }`) would otherwise be swallowed whole by the opaque-block
+    // preservation above — this walk never recurses into it, so neither
+    // `jsxConstants` nor `jsxReturn` ever get set and the component
+    // silently produces zero files, zero diagnostics. Detect the shape
+    // before preserving it and report loudly instead.
+    if (ts.isBlock(node)) {
+      const returnedLocal = findBlockBodyReturnedJsxLocalName(node)
+      if (returnedLocal) {
+        ctx.errors.push(createError(
+          ErrorCodes.RETURN_VALUE_NOT_JSX,
+          getSourceLocation(node, ctx.sourceFile, ctx.filePath),
+          {
+            message:
+              `Component '${ctx.componentName ?? '(unknown)'}' return value is not recognized ` +
+              `as JSX — return the JSX expression directly instead of binding it to a local ` +
+              `variable first (\`return ${returnedLocal}\` after \`const ${returnedLocal} = ` +
+              `<jsx/>\` is not resolved at return position).`,
+          },
+        ))
+      }
+    }
     collectInitStatement(node, ctx)
     return
   }
@@ -886,6 +909,54 @@ export function unwrapJsxTransparent(expr: ts.Expression): ts.Expression {
   return current
 }
 
+/**
+ * BF027 (#2720) shape detector: a block whose last statement returns a
+ * bare identifier, where some earlier statement in the SAME block declares
+ * that identifier as a `const`/`let` initialized to JSX (root JSX, or JSX
+ * nested in a ternary/`&&`/`||`/`??`) — `{ const __root = <jsx/>; return
+ * __root }`. Mirrors the same two "does this initializer hold JSX" checks
+ * `collectConstant` uses to populate `jsxConstants` / `inlineableJsxConsts`
+ * for ordinary top-level locals, applied here to a nested block that would
+ * otherwise never be walked (it is preserved whole as an opaque init
+ * statement, see #930). Returns the identifier's name on a match, else
+ * null — deliberately narrow (exact "name, then return that name" shape)
+ * so an ordinary block scoping unrelated imperative logic is untouched.
+ */
+function findBlockBodyReturnedJsxLocalName(block: ts.Block): string | null {
+  const stmts = block.statements
+  const last = stmts[stmts.length - 1]
+  if (!last || !ts.isReturnStatement(last) || !last.expression) return null
+  const returned = unwrapJsxTransparent(last.expression)
+  if (!ts.isIdentifier(returned)) return null
+  const name = returned.text
+
+  for (const stmt of stmts) {
+    if (!ts.isVariableStatement(stmt)) continue
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name) || decl.name.text !== name || !decl.initializer) continue
+      let init: ts.Expression = decl.initializer
+      while (ts.isParenthesizedExpression(init)) init = init.expression
+      if (
+        ts.isJsxElement(init) ||
+        ts.isJsxSelfClosingElement(init) ||
+        ts.isJsxFragment(init) ||
+        initializerShapeContainsJsx(init) ||
+        // `initializerShapeContainsJsx` deliberately stops at arrow
+        // boundaries, so a `.map()`/`.flatMap()` whose CALLBACK returns JSX
+        // needs the same dedicated check `collectConstant` uses to admit
+        // that shape into `inlineableJsxConsts` (#1554) — without it,
+        // `{ const __root = items.map(i => <div/>); return __root }` slips
+        // past BF027 back into the silent-drop path (Copilot review on
+        // #2726).
+        isMapLikeCallWithJsx(init)
+      ) {
+        return name
+      }
+    }
+  }
+  return null
+}
+
 /**
  * Extract JSX element from an expression, handling parenthesized
  * expressions and TS type-only wrappers (`as`, `satisfies`, `!`,

package/src/errors.ts

@@ -22,11 +22,24 @@ export const ErrorCodes = {
   // Signal/Memo errors (BF011-BF019)
   SIGNAL_OUTSIDE_COMPONENT: 'BF011',
 
-  // JSX errors (BF021-BF029)
+  // JSX errors (BF021-BF029). BF022 was retired (see
+  // `invalid-jsx-attribute.audit.test.ts`) and BF026 is reserved by
+  // `spec/callback-fidelity.md` for a future `.map()`-callback-shape
+  // diagnostic — BF027 is the next free slot.
   UNSUPPORTED_JSX_PATTERN: 'BF021',
   MISSING_KEY_IN_LIST: 'BF023',
   MISSING_KEY_IN_NESTED_LIST: 'BF024',
   UNSUPPORTED_DESTRUCTURE_REST: 'BF025',
+  // The component's return statement resolves to a bare identifier that
+  // refers to a local `const`/`let` whose initializer IS JSX (or a
+  // JSX-shaped ternary/`&&`/`||`/`??`), e.g. `const __root = <div/>; return
+  // __root`. JSX-child position resolves such identifiers through
+  // `jsxConstants` / `inlineableJsxConsts` (#547 / #1409), but return
+  // position deliberately does not (see `transformExpressionInner`'s
+  // docstring) — so the dispatcher's scalar-leaf fallback silently produces
+  // no IR and no diagnostic (#2720). Loud stopgap until the analyzer learns
+  // to resolve the identifier at return position too.
+  RETURN_VALUE_NOT_JSX: 'BF027',
 
   // Component errors (BF043-BF049)
   PROPS_DESTRUCTURING: 'BF043',
@@ -152,6 +165,9 @@ const errorMessages: Record<ErrorCode, string> = {
     // stable.
     'Computed property key in .map() callback destructure is not supported. Rewrite the callback to destructure explicit bindings (e.g., `({ a, b }) => ...`) so the compiler can rewrite references to per-item signal accessors.',
 
+  [ErrorCodes.RETURN_VALUE_NOT_JSX]:
+    "Component's return value is not recognized as JSX — return the JSX expression directly instead of binding it to a local variable first.",
+
   [ErrorCodes.PROPS_DESTRUCTURING]:
     'Props destructuring in function parameters breaks reactivity. Use props object directly.',
   [ErrorCodes.SIGNAL_GETTER_NOT_CALLED]: