@barefootjs/jsx 0.29.0 → 0.30.2

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

@@ -30,7 +30,7 @@ import { irChildrenToJsExpr, renderPreamble, irToHtmlTemplate } from '../html-te
 function staticPreludeStatements(preamble: MapCallbackPreamble | undefined): string[] {
   return preamble
     ? [renderPreamble(preamble, {
-        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined, true),
+        renderLeaf: (ir) => irToHtmlTemplate(ir, undefined, 1, undefined, undefined),
       })]
     : []
 }

package/src/ir-to-client-js/plan/declaration-emit.ts

@@ -27,6 +27,12 @@ export interface SignalEmitPlan {
   getter: string
   /** Setter identifier — `null` for read-only signals. */
   setter: string | null
+  /**
+   * Source used the getter-elided form (`const [, setX] = ...`). `getter`
+   * holds the synthesized internal name (see `SignalInfo.getterElided`);
+   * stringify reproduces the source's hole instead of emitting it.
+   */
+  getterElided?: boolean
   /**
    * Fully-resolved initial value expression. Prop rewrites
    * (`<propsName>.X` → `_p.X`) and `?? <default>` insertions for controlled

package/src/ir-to-client-js/reactivity.ts

@@ -16,6 +16,7 @@ import type {
 } from './types.ts'
 import { attrValueToString, freeIdsFromRefs, tokenContainsIdent } from './utils.ts'
 import { expandConstantForReactivity } from './prop-handling.ts'
+import { extractFreeIdentifiersFromText } from './csr-substitute.ts'
 import { walkIR, stopAt } from './walker.ts'
 
 /**
@@ -621,12 +622,20 @@ export function collectLoopChildReactiveTexts(
  * same semantics. Pass true only when the caller also separately collects
  * nested reactive conditionals and gives each its own `insert()`.
  */
+/** Does any name in `names` appear in `set`? Iterates rather than
+ *  spreading — this runs per attribute (Copilot review). */
+function anyNameIn(names: Iterable<string>, set: ReadonlySet<string>): boolean {
+  for (const n of names) if (set.has(n)) return true
+  return false
+}
+
 export function collectLoopChildReactiveAttrs(
   node: IRNode,
   ctx: ClientJsContext,
   loopParam?: string,
   loopParamBindings?: readonly LoopParamBinding[],
   stopAtReactiveConditionals = false,
+  preambleNames?: ReadonlySet<string>,
 ): LoopChildReactiveAttr[] {
   const attrs: LoopChildReactiveAttr[] = []
   traverseElements(node, (el) => {
@@ -664,8 +673,23 @@ export function collectLoopChildReactiveAttrs(
         // / `hasFunctionCalls` fallback so the loop-child path matches the
         // top-level one — a harmless over-wrap at worst (an effect that
         // subscribes to nothing runs once).
+        // A `.map()` callback preamble local (#2447 follow-up). The
+        // classifier cannot see it: `const cls = row.done ? …` makes `cls`
+        // neither a signal read nor a loop-param read, so `class={cls}`
+        // scored 'none' and the value froze at its row-construction value —
+        // a same-key item update rewrote the sibling `{row.label}` text and
+        // left the class stale. Its reactivity is the PREAMBLE's: whatever
+        // the initializer read. Flag it and let the emitter re-run the
+        // preamble ahead of the write (`stringifyReactiveEffects`), which is
+        // the child-position `preambleRegions` treatment (#2389) applied to
+        // the attribute position.
+        const readsPreamble =
+          preambleNames !== undefined &&
+          preambleNames.size > 0 &&
+          anyNameIn(expanded.freeIds ?? extractFreeIdentifiersFromText(expanded.expr), preambleNames)
         const reactive =
           classifyReactivity(expanded.expr, ctx, loopParam, loopParamBindings, expanded.freeIds).kind !== 'none'
+          || readsPreamble
           || attr.callsReactiveGetters
           || attr.hasFunctionCalls
         if (!attr.clientOnly && !reactive) continue
@@ -675,6 +699,7 @@ export function collectLoopChildReactiveAttrs(
           expression: expanded.expr,
           ...pickAttrMetaFromIR(attr),
           ...(expanded.freeIds !== undefined && { freeIdentifiers: expanded.freeIds }),
+          ...(readsPreamble && { readsPreamble: true }),
         })
       }
     }

package/src/ir-to-client-js/stringify/declaration-emit.ts

@@ -65,12 +65,17 @@ function bfIdArg(bfId: string | undefined): string {
 }
 
 function emitSignal(lines: string[], plan: SignalEmitPlan): void {
+  // Getter-elided source form (`const [, setX] = createSignal(...)`):
+  // reproduce the hole instead of introducing the synthesized internal
+  // getter name into output (#2468 sweep — dropping the declaration
+  // entirely left the setter as a guaranteed ReferenceError).
+  const getterSlot = plan.getterElided ? '' : plan.getter
   // Env signal (#2057): emit its own factory call verbatim (`createSearchParams()`)
   // — a stable request-scoped view, so no baked initial value, profile id,
   // controlled effect, or branch condition applies.
   if (plan.initializerOverride) {
     if (plan.setter) {
-      lines.push(`  const [${plan.getter}, ${plan.setter}] = ${plan.initializerOverride}`)
+      lines.push(`  const [${getterSlot}, ${plan.setter}] = ${plan.initializerOverride}`)
     } else {
       lines.push(`  const [${plan.getter}] = ${plan.initializerOverride}`)
     }
@@ -85,9 +90,9 @@ function emitSignal(lines: string[], plan: SignalEmitPlan): void {
     // runs when the branch is taken. Sibling branches with different
     // signals coexist because each gets its own `let` + guarded assign.
     if (plan.setter) {
-      lines.push(`  let ${plan.getter}, ${plan.setter}`)
+      lines.push(plan.getterElided ? `  let ${plan.setter}` : `  let ${plan.getter}, ${plan.setter}`)
       lines.push(`  if (${plan.branchCondition}) {`)
-      lines.push(`    ;[${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`)
+      lines.push(`    ;[${getterSlot}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`)
       lines.push(`  }`)
     } else {
       lines.push(`  let ${plan.getter}`)
@@ -101,7 +106,7 @@ function emitSignal(lines: string[], plan: SignalEmitPlan): void {
     return
   }
   if (plan.setter) {
-    lines.push(`  const [${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`)
+    lines.push(`  const [${getterSlot}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`)
   } else {
     lines.push(`  const [${plan.getter}] = createSignal(${plan.initialValueExpr}${id})`)
   }

package/src/ir-to-client-js/types.ts

@@ -494,6 +494,18 @@ export interface LoopChildReactiveAttr extends AttrMeta {
   childSlotId: string // bf slot ID of the element with reactive attr
   attrName: string // 'className', 'disabled', etc.
   expression: string // Expression that reads signals
+  /**
+   * The expression reads a `.map()` callback preamble local (#2447
+   * follow-up), so it is reactive by way of whatever the preamble read — the
+   * classifier cannot see through the declaration, and the local is not in
+   * scope in the update body until the preamble is re-run there.
+   *
+   * Two consequences, both handled by the emitter rather than here: the row
+   * effect runs `mapPreambleWrapped` BEFORE the attr writes, and the lazy row
+   * graph refuses the loop (`lazyRowEligibility`'s `readsPreamble` gate), so
+   * such a row keeps the eager per-row effect.
+   */
+  readsPreamble?: boolean
 }
 
 export interface LoopChildReactiveText {