@barefootjs/jsx 0.35.2 → 0.35.3

package/src/ir-to-client-js/stringify/static-array-child-init.ts

@@ -58,6 +58,10 @@ import type {
   StaticArrayChildInitsPlan,
 } from '../plan/static-array-child-init.ts'
 import { nameForRegistryRef } from '../component-scope.ts'
+import { varSlotId } from '../utils.ts'
+import { emitDedupedAttrUpdate, DEDUP_STORE_DECL } from '../emit-reactive.ts'
+import { claimPlanLiteral, claimWriterVarName, type ClaimSlotSpec } from '../control-flow/stringify/claim-plan.ts'
+import { emitLoopChildRefs } from '../control-flow/stringify/loop.ts'
 
 export function stringifyStaticArrayChildInits(
   lines: string[],
@@ -142,6 +146,9 @@ function emitInnerLoopNested(lines: string[], plan: InnerLoopNestedInitPlan): vo
     innerPreludeStatements,
     depth,
     comps,
+    attrsBySlot,
+    texts,
+    refs,
   } = plan
   lines.push(`  // Initialize inner-loop components in static array (depth ${depth})`)
   lines.push(`  if (${containerVar}) {`)
@@ -174,6 +181,38 @@ function emitInnerLoopNested(lines: string[], plan: InnerLoopNestedInitPlan): vo
     lines.push(`        const ${compElVar} = qsaChildScope(__innerEl, ${comp.selector})`)
     lines.push(`        if (${compElVar}) initChild('${nameForRegistryRef(comp.componentName)}', ${compElVar}, ${comp.propsExpr})`)
   })
+  // Plain-element reactive attrs / texts / refs inside this inner loop's
+  // body (#2798) — mirrors `stringifyStaticLoop`'s own per-row wiring for
+  // the OUTER static loop, one nesting level in. `forEach` binds
+  // `innerParam` as the raw item value, so `texts`/`attrsBySlot`
+  // expressions stay unwrapped, same as the outer row.
+  if (attrsBySlot.length > 0) lines.push(`        ${DEDUP_STORE_DECL}`)
+  let ordinal = 0
+  for (const [slotId, attrs] of attrsBySlot) {
+    const varName = `__t_${varSlotId(slotId)}`
+    lines.push(`        const ${varName} = qsa(__innerEl, '[bf="${slotId}"]')`)
+    lines.push(`        if (${varName}) {`)
+    for (const attr of attrs) {
+      lines.push(`          createEffect(() => {`)
+      for (const stmt of emitDedupedAttrUpdate(varName, attr.attrName, attr.expression, attr, ordinal++)) {
+        lines.push(`            ${stmt}`)
+      }
+      lines.push(`          })`)
+    }
+    lines.push(`        }`)
+  }
+  if (texts.length > 0) {
+    const slots: ClaimSlotSpec[] = texts.map(t => ({ id: t.slotId, kind: 'text', path: [] }))
+    const writer = claimWriterVarName(slots, varSlotId)
+    lines.push(`        const ${writer} = lazySlots(__innerEl, ${claimPlanLiteral(slots)})`)
+    for (const text of texts) {
+      lines.push(`        createEffect(() => { ${writer}('${text.slotId}', String(${text.expression})) })`)
+    }
+  }
+  // Ref callbacks fire on every forEach iteration — initial mount and any
+  // future array-change-driven re-iteration. For a static array the array
+  // is non-reactive, so refs effectively fire once per item (#1244).
+  emitLoopChildRefs(lines, refs, { indent: '        ', elVar: '__innerEl', bodyIsMultiRoot: false })
   lines.push(`      })`)
   lines.push(`    })`)
   lines.push(`  }`)

package/src/jsx-to-ir.ts

@@ -49,6 +49,7 @@ import { containsReactiveExpression, collectReactiveBrandLeaves } from './reacti
 import {
   rewriteBarePropRefs as rewriteBarePropRefsCore,
   collectAstPropRefs,
+  rewriteScopedValueRefs,
 } from './prop-rewrite.ts'
 import { boundPropLocalNames, buildPropAliasMap, resolveAliasOrigin, resolveRestSpreadOriginCore } from './props-binding.ts'
 import { resolveFreeRefs, isNameBound as isNameBoundInEnv, type BindingEnvironment } from './free-refs.ts'
@@ -8456,10 +8457,19 @@ function inferExpressionType(
 
 /**
  * Substitute branch-local identifier references in `text` with the
- * value returned by `resolve(name)`. Skips occurrences inside string
- * / regex / template-body / comment tokens via the shared
- * `replaceInExprContexts` scanner, so a string like `'mergedClass'`
- * never gets rewritten into invalid JS. Identifier boundaries use
+ * value returned by `resolve(name)`. Tries the AST-based, scope-aware
+ * `rewriteScopedValueRefs` (`prop-rewrite.ts`) first — it correctly
+ * expands an object-literal shorthand property (`{ local }`) to
+ * `{ local: <resolved> }` instead of corrupting it to `{ (<resolved>) }`
+ * (#2856), and understands inner-scope shadowing. `allowStatements`
+ * covers raw-captured text that isn't guaranteed to be a bare
+ * expression (e.g. a `.map()`-callback preamble statement).
+ *
+ * Falls back to the legacy `replaceInExprContexts` scanner — which
+ * skips occurrences inside string / regex / template-body / comment
+ * tokens, so a string like `'mergedClass'` never gets rewritten into
+ * invalid JS, but has no notion of AST position — only when `text`
+ * doesn't parse under either attempt. Identifier boundaries use
  * `[\w$]` lookarounds rather than `\b`, since JS regex's word-char
  * class excludes `$` — a bare `\b` would mis-match the `foo` inside
  * `$foo`. Branch-local names are syntactically `[A-Za-z_$][A-Za-z0-9_$]*`
@@ -8478,6 +8488,8 @@ function replaceBranchLocalRefs(
   resolve: (name: string) => string,
 ): string {
   if (branchNames.length === 0) return text
+  const astResult = rewriteScopedValueRefs(text, new Set(branchNames), resolve, { allowStatements: true })
+  if (astResult !== null) return astResult
   const pattern = new RegExp(`(?<![\\w$])(${branchNames.join('|')})(?![\\w$])`, 'g')
   return replaceInExprContexts(text, pattern, (_match, name) => resolve(name))
 }

package/src/prop-rewrite.ts

@@ -89,8 +89,16 @@ function walkWithScope(
 /**
  * True when `n` sits in a non-value position where a prop rewrite must
  * never apply: an object-literal key, a member-access name, a binding
- * position (parameter / variable / binding-element name), or a type
- * reference.
+ * position (parameter / variable / binding-element name), a destructuring
+ * declaration's SOURCE key (`propertyName`, e.g. the `local` in
+ * `const { local: renamed } = obj`), or a type reference.
+ *
+ * The `propertyName` check matters even though `BindingElement.name` is
+ * already excluded above it: a renamed destructuring pattern has BOTH —
+ * `propertyName` is the source key (`local`) and `name` is the local
+ * binding (`renamed`) — and pullfrog review on #2889 caught that only the
+ * latter was excluded, so a substituted name colliding with the SOURCE key
+ * still corrupted to invalid JS (`const { (_p.tag): renamed } = obj`).
  */
 function isNonValuePosition(n: ts.Identifier, parent: ts.Node | undefined): boolean {
   if (!parent) return false
@@ -98,6 +106,7 @@ function isNonValuePosition(n: ts.Identifier, parent: ts.Node | undefined): bool
   if (ts.isPropertyAccessExpression(parent) && parent.name === n) return true
   if (ts.isQualifiedName(parent) && parent.right === n) return true
   if ((ts.isParameter(parent) || ts.isVariableDeclaration(parent) || ts.isBindingElement(parent)) && parent.name === n) return true
+  if (ts.isBindingElement(parent) && parent.propertyName === n) return true
   if (ts.isTypeReferenceNode(parent)) return true
   return false
 }
@@ -130,49 +139,54 @@ export function collectAstPropRefs(
 
 /**
  * Scope-aware rewrite: parse `text` as an expression, walk it with the
- * binding stack, and splice `${PROPS_PARAM}.` onto exactly the
- * identifier references that are (a) in `propRefs` and (b) not
- * shadowed by a binding inside the text. Shorthand properties expand
- * (`{ org }` → `{ org: _p.org }`) so the result stays syntactically
- * valid.
+ * binding stack, and splice `replacementFor(name)` onto exactly the
+ * identifier references that are (a) in `names` and (b) not shadowed by
+ * a binding inside the text. Shorthand properties expand
+ * (`{ org }` → `{ org: <replacement> }`) so the result stays
+ * syntactically valid — this is the one place in the compiler that
+ * correctly distinguishes a value reference from an object-literal key
+ * / property-access name / shorthand property / binding name, so every
+ * caller doing this class of substitution (prop refs, #1425 branch-local
+ * refs, …) should route through this rather than growing its own
+ * regex-based text splice (#2856 — a second, regex-based substitution
+ * mechanism doesn't know shorthand is simultaneously a key and a value,
+ * and drops the key).
  *
- * `replacementFor` overrides the substitution text for a value
- * reference (default `${PROPS_PARAM}.<callerKey>`) — e.g. the reactive
- * client-JS emit path (`emit-reactive.ts`'s `rewriteDestructuredPropsInExpr`)
- * wraps it in a `(_p.x ?? <default>)` fallback for a prop with a
- * destructure default. Kept as a caller override rather than a
- * duplicate AST walk in that module, per the "one decision, one
- * implementation" rule (CLAUDE.md) — this walk is already the one place
- * that correctly distinguishes a value reference from an object-literal
- * key / property-access name / shorthand property / binding name.
+ * With `allowStatements`, a `text` that fails to parse as a bare
+ * expression is retried as a standalone statement list (no wrapping
+ * parens) — for callers whose raw-captured text isn't guaranteed to be
+ * expression-shaped (e.g. a `.map()`-callback preamble statement).
  *
- * Returns null when `text` does not parse cleanly as an expression —
- * the caller falls back to the legacy regex rewrite.
+ * Returns null when `text` doesn't parse cleanly under either attempt —
+ * the caller falls back to its own legacy mechanism.
  */
-function applyScopedPropRefRewrite(
+export function rewriteScopedValueRefs(
   text: string,
-  propRefs: Set<string>,
-  propAliases?: ReadonlyMap<string, string>,
-  replacementFor?: (localName: string, callerKey: string) => string,
+  names: ReadonlySet<string>,
+  replacementFor: (name: string) => string,
+  opts?: { allowStatements?: boolean },
 ): string | null {
   // Wrap in parens so object literals and arrows parse as expressions.
   const prefix = '('
-  const sf = ts.createSourceFile('__bf_prop_rewrite.ts', `${prefix}${text}\n)`, ts.ScriptTarget.Latest, true)
-  const parseDiagnostics = (sf as unknown as { parseDiagnostics?: unknown[] }).parseDiagnostics
-  if (parseDiagnostics && parseDiagnostics.length > 0) return null
+  let sf = ts.createSourceFile('__bf_scoped_rewrite.ts', `${prefix}${text}\n)`, ts.ScriptTarget.Latest, true)
+  let parseDiagnostics = (sf as unknown as { parseDiagnostics?: unknown[] }).parseDiagnostics
+  let usedPrefix = prefix
+  if (parseDiagnostics && parseDiagnostics.length > 0) {
+    if (!opts?.allowStatements) return null
+    sf = ts.createSourceFile('__bf_scoped_rewrite.ts', text, ts.ScriptTarget.Latest, true)
+    parseDiagnostics = (sf as unknown as { parseDiagnostics?: unknown[] }).parseDiagnostics
+    if (parseDiagnostics && parseDiagnostics.length > 0) return null
+    usedPrefix = ''
+  }
 
   const edits: Array<{ start: number; end: number; replacement: string }> = []
   walkWithScope(sf, (n, parent, shadowed) => {
-    if (shadowed || !propRefs.has(n.text)) return
+    if (shadowed || !names.has(n.text)) return
     if (isNonValuePosition(n, parent)) return
-    const start = n.getStart(sf) - prefix.length
-    const end = n.getEnd() - prefix.length
+    const start = n.getStart(sf) - usedPrefix.length
+    const end = n.getEnd() - usedPrefix.length
     if (start < 0 || end > text.length) return
-    // `_p` is always keyed by the caller-facing name (`sourceName ?? name`
-    // — #2524 CSR half); the local binding (`n.text`) only survives on the
-    // left of a shorthand expansion.
-    const callerKey = propAliases?.get(n.text) ?? n.text
-    const value = replacementFor ? replacementFor(n.text, callerKey) : `${PROPS_PARAM}.${callerKey}`
+    const value = replacementFor(n.text)
     if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === n) {
       edits.push({ start, end, replacement: `${n.text}: ${value}` })
       return
@@ -188,6 +202,33 @@ function applyScopedPropRefRewrite(
   return result
 }
 
+/**
+ * `applyScopedPropRefRewrite` specializes `rewriteScopedValueRefs` for
+ * the destructured-prop case: the substitution defaults to
+ * `${PROPS_PARAM}.<callerKey>`, where the caller-facing key comes from
+ * `propAliases` (`_p` is always keyed by the caller-facing name —
+ * `sourceName ?? name`, #2524 CSR half — the local binding only
+ * survives on the left of a shorthand expansion).
+ *
+ * `replacementFor` overrides the substitution text for a value
+ * reference — e.g. the reactive client-JS emit path
+ * (`emit-reactive.ts`'s `rewriteDestructuredPropsInExpr`) wraps it in a
+ * `(_p.x ?? <default>)` fallback for a prop with a destructure default.
+ * Kept as a caller override rather than a duplicate AST walk in that
+ * module, per the "one decision, one implementation" rule (CLAUDE.md).
+ */
+function applyScopedPropRefRewrite(
+  text: string,
+  propRefs: Set<string>,
+  propAliases?: ReadonlyMap<string, string>,
+  replacementFor?: (localName: string, callerKey: string) => string,
+): string | null {
+  return rewriteScopedValueRefs(text, propRefs, (name) => {
+    const callerKey = propAliases?.get(name) ?? name
+    return replacementFor ? replacementFor(name, callerKey) : `${PROPS_PARAM}.${callerKey}`
+  })
+}
+
 /**
  * Apply the targeted regex rewrite for one or more prop names on a
  * type-stripped expression text. Idempotent under `_p.X` (negative