@barefootjs/jsx 0.31.10 → 0.33.0

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