@barefootjs/jsx 0.32.0 → 0.33.0

package/src/ssr-seed-plan.ts

@@ -36,7 +36,7 @@ import {
   extractArrowBodyExpression,
   freeIdentifiers,
   inlineBinding,
-  isSupported,
+  isSupportedValue,
   parseExpression,
   type ParsedExpr,
 } from './expression-parser.ts'
@@ -81,6 +81,11 @@ export interface SsrSeedPlan {
  * opaque). The scope check runs over the parsed SOURCE tree, so a shadowed
  * name (`items.filter((p) => p.ok) && p`, where the trailing `p` is a
  * different, unbound reference from the callback's own param) is rejected.
+ *
+ * Uses `isSupportedValue`, not `isSupported`: a signal/memo initializer is an
+ * ASSIGNMENT, never a render, so it's checked at VALUE position — this is
+ * what admits e.g. `createSignal([{ a: 'p' }].map(t => t.a).join(','))`
+ * (an object-literal array-method receiver) as `derived` instead of opaque.
  */
 function classify(
   name: string,
@@ -89,7 +94,7 @@ function classify(
   parsed: ParsedExpr,
   available: ReadonlySet<string>,
 ): SsrSeedStep {
-  if (!isSupported(parsed).supported) return { kind: 'opaque', name, origin }
+  if (!isSupportedValue(parsed).supported) return { kind: 'opaque', name, origin }
   const frees = freeIdentifiers(parsed)
   if (frees === null) return { kind: 'opaque', name, origin }
   for (const free of frees) {
@@ -198,7 +203,19 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
             signal.getter,
             'signal',
             expr,
-            resolveThroughLocalConsts(parseExpression(expr), localConsts),
+            // Prefer the analyzer's already-parenthesised parse (`analyzer.ts`'s
+            // `parseExpression(\`(${signal.initialValue})\`)`, Roadmap A) over
+            // re-parsing the bare `expr` string here — re-parsing WITHOUT the
+            // wrap misreads a bare object-literal initializer
+            // (`createSignal({ ...base, done: true })`) as a block statement
+            // (`parseExpression`'s documented block-vs-expression-statement
+            // rule), silently opaquing an otherwise-derivable signal (#2696
+            // Step 2 follow-up: this only became observable once `object-
+            // literal` could classify `derived` at all). Falling back to a
+            // parenthesised re-parse (not the bare string) keeps a signal
+            // whose shape the analyzer's pass left unparsed (`signal.parsed`
+            // undefined) equally safe.
+            resolveThroughLocalConsts(signal.parsed ?? parseExpression(`(${expr})`), localConsts),
             available,
           ),
     )

package/src/static-literal.ts

@@ -60,9 +60,23 @@ export function evaluateStaticLiteral(
       // Shorthand (`{ a }`) and explicit (`{ a: value }`) properties both
       // carry their resolved tree in `value` (shorthand's is an
       // `identifier`) — recursing here handles both uniformly: a shorthand
-      // property only resolves when `bindings` supplies it.
+      // property only resolves when `bindings` supplies it. A spread
+      // (`{ ...base, a: 1 }`, #2696 Step 2) resolves its source and merges
+      // in source order — the same shallow-merge, later-wins, null/undefined-
+      // is-a-no-op semantics as the runtime evaluator (`toEvalNode`'s
+      // `object-literal` case) and JS itself; a spread source that resolves
+      // to anything other than a plain object/null/undefined isn't
+      // statically mergeable here, so the whole literal declines.
       const out: Record<string, unknown> = {}
       for (const prop of expr.properties) {
+        if (prop.kind === 'spread') {
+          const resolved = evaluateStaticLiteral(prop.expr, bindings)
+          if (!resolved) return null
+          if (resolved.value === null || resolved.value === undefined) continue
+          if (typeof resolved.value !== 'object' || Array.isArray(resolved.value)) return null
+          Object.assign(out, resolved.value)
+          continue
+        }
         const resolved = evaluateStaticLiteral(prop.value, bindings)
         if (!resolved) return null
         out[prop.key] = resolved.value

package/src/to-locale-date-lowering.ts

@@ -504,6 +504,10 @@ export function matchToLocaleDateStringCall(
   let tz: string | null = null
   const probeOptions: Record<string, string> = {}
   for (const prop of options.properties) {
+    // A spread (`{ ...opts, timeZone: 'UTC' }`, #2696 Step 2) isn't a
+    // literal-keyed entry this probe can read without evaluating the spread
+    // source — decline rather than silently skipping its keys.
+    if (prop.kind === 'spread') return null
     if (prop.value.kind !== 'literal' || prop.value.literalType !== 'string') return null
     const value = String(prop.value.value)
     if (prop.key === 'timeZone') {