@barefootjs/jsx 0.33.3 → 0.33.6

package/src/prop-rewrite.ts

@@ -132,6 +132,16 @@ export function collectAstPropRefs(
  * (`{ org }` → `{ org: _p.org }`) so the result stays syntactically
  * valid.
  *
+ * `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.
+ *
  * Returns null when `text` does not parse cleanly as an expression —
  * the caller falls back to the legacy regex rewrite.
  */
@@ -139,6 +149,7 @@ function applyScopedPropRefRewrite(
   text: string,
   propRefs: Set<string>,
   propAliases?: ReadonlyMap<string, string>,
+  replacementFor?: (localName: string, callerKey: string) => string,
 ): string | null {
   // Wrap in parens so object literals and arrows parse as expressions.
   const prefix = '('
@@ -157,11 +168,12 @@ function applyScopedPropRefRewrite(
     // — #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}`
     if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === n) {
-      edits.push({ start, end, replacement: `${n.text}: ${PROPS_PARAM}.${callerKey}` })
+      edits.push({ start, end, replacement: `${n.text}: ${value}` })
       return
     }
-    edits.push({ start, end, replacement: `${PROPS_PARAM}.${callerKey}` })
+    edits.push({ start, end, replacement: value })
   })
 
   if (edits.length === 0) return text
@@ -186,6 +198,7 @@ export function applyRegexPropRefRewrite(
   text: string,
   propRefs: Iterable<string>,
   propAliases?: ReadonlyMap<string, string>,
+  replacementFor?: (localName: string, callerKey: string) => string,
 ): string {
   const { protect, restore } = createTemplateAwareStringProtector()
   let result = protect(text)
@@ -193,6 +206,7 @@ export function applyRegexPropRefRewrite(
   for (const propName of propRefs) {
     // `_p` is always keyed by the caller-facing name (#2524 CSR half).
     const callerKey = propAliases?.get(propName) ?? propName
+    const value = replacementFor ? replacementFor(propName, callerKey) : `${PROPS_PARAM}.${callerKey}`
     const pattern = new RegExp(`(?<!${PROPS_PARAM}\\.)(?<!['"\\w.-])\\b${propName}\\b(?![a-zA-Z0-9_$])`, 'g')
     result = result.replace(pattern, (match, offset, str) => {
       // Skip object literal keys: preceded by { or , and followed by :
@@ -201,7 +215,7 @@ export function applyRegexPropRefRewrite(
         const before = str.slice(0, offset)
         if (/[{,]\s*$/.test(before)) return match
       }
-      return `${PROPS_PARAM}.${callerKey}`
+      return value
     })
   }
 
@@ -225,6 +239,9 @@ export function applyRegexPropRefRewrite(
  *   `_p` is always keyed by the caller-facing name (#2524 CSR half); a name
  *   absent from this map emits `_p.<name>` unchanged (the un-aliased case,
  *   where `sourceName ?? name` is an identity).
+ * @param replacementFor - Override the substitution text for a value
+ *   reference (default `${PROPS_PARAM}.<callerKey>`) — see
+ *   `applyScopedPropRefRewrite`'s docstring.
  */
 export function rewriteBarePropRefs(
   text: string,
@@ -232,6 +249,7 @@ export function rewriteBarePropRefs(
   propNames: Set<string>,
   extraPropRefs?: ReadonlySet<string>,
   propAliases?: ReadonlyMap<string, string>,
+  replacementFor?: (localName: string, callerKey: string) => string,
 ): string | undefined {
   // Walk AST to find which prop names are actually used as value references
   const foundPropRefs = new Set<string>()
@@ -243,7 +261,7 @@ export function rewriteBarePropRefs(
   }
   if (foundPropRefs.size === 0) return undefined
   return (
-    applyScopedPropRefRewrite(text, foundPropRefs, propAliases) ??
-    applyRegexPropRefRewrite(text, foundPropRefs, propAliases)
+    applyScopedPropRefRewrite(text, foundPropRefs, propAliases, replacementFor) ??
+    applyRegexPropRefRewrite(text, foundPropRefs, propAliases, replacementFor)
   )
 }

package/src/props-binding.ts

@@ -69,6 +69,31 @@ export function buildPropAliasMap(params: readonly ParamInfo[]): Map<string, str
   return map
 }
 
+/**
+ * The props-parameter shape needed to answer "is `name` an actual local
+ * binding introduced by the props parameter" — as opposed to
+ * `ctx.patterns.props`, which for a whole `(props: Props)` parameter holds
+ * every TYPE-MEMBER name (`extractPropsFromTypeMembers`) for regex prop-
+ * access matching, not real bindings.
+ */
+export interface PropsParamBindings {
+  propsParams: readonly ParamInfo[]
+  propsObjectName: string | null
+}
+
+/**
+ * Local names actually bound by the props parameter. Empty for a whole
+ * `(props: Props)` parameter: `propsParams` there is type-member names
+ * (nothing local to shadow with), and `props` itself is `propsObjectName`,
+ * checked separately by callers.
+ */
+export function boundPropLocalNames(b: PropsParamBindings): ReadonlySet<string> {
+  if (b.propsObjectName !== null) return EMPTY_SET
+  return new Set(b.propsParams.filter(p => !p.isRest).map(p => p.name))
+}
+
+const EMPTY_SET: ReadonlySet<string> = new Set()
+
 /**
  * The two component bindings that forward the caller's leftover props:
  * the destructured `...rest` binding and a whole undestructured `(props)`
@@ -82,10 +107,52 @@ export interface RestSpreadBindings {
 }
 
 /**
- * Which of `bindings` the name `name` ultimately reaches, walking through
- * any bare `const x__alias = <name>` hop recorded in `constantValues`
- * (name → initializer text). `'rest'` for the destructured rest binding,
- * `'props'` for the whole props object, `null` for anything else.
+ * Walks a bare `const x__alias = <name>` hop chain recorded in
+ * `constantValues` (name → initializer text) until `terminal` recognizes
+ * the current name, returning what it recognized. `null` when the chain
+ * runs out (a constant whose value isn't a bare identifier — a real
+ * computed object — stops the walk) or degenerates into a cycle.
+ *
+ * The one alias-hop walker in the compiler, shared by every caller that
+ * needs "does this name ultimately reach some fixed binding" rather than
+ * a bespoke copy per caller — `resolveRestSpreadOriginCore` below,
+ * `resolveGetterAliases` (`csr-substitute.ts`, #2778), and
+ * `isArrayExprDirectPropRef` (`jsx-to-ir.ts`, #2724, called directly rather
+ * than through a `*Core`-style wrapper) are its callers, differing only in
+ * what `terminal` recognizes as a hit — and, for `isArrayExprDirectPropRef`,
+ * in also narrowing `constantValues` itself (`propAliasHopCandidates`)
+ * before passing it in. `terminal` is checked BEFORE the constant-value
+ * lookup so a name that is itself a target take priority over any
+ * same-named local shadowing it (preserves `resolveRestSpreadOriginCore`'s
+ * original hop order) — a caller whose `terminal` can itself be fooled by a
+ * shadowed name (e.g. a scope-unaware lookup keyed only by name) must guard
+ * that inside `terminal`, since this walker has no scope/binding awareness
+ * of its own to do it centrally.
+ *
+ * `visited` guards a constant cycle (`const a = b; const b = a`); walking
+ * hop by hop (not a precomputed set) is what lets a multi-hop alias
+ * (`const p2 = props; const p3 = p2`) resolve through every link.
+ */
+export function resolveAliasOrigin<T>(
+  constantValues: ReadonlyMap<string, string | undefined>,
+  name: string,
+  terminal: (name: string) => T | null,
+): T | null {
+  const visited = new Set<string>()
+  let current: string | undefined = name.trim()
+  while (current !== undefined && !visited.has(current)) {
+    const hit = terminal(current)
+    if (hit !== null) return hit
+    visited.add(current)
+    current = constantValues.get(current)?.trim()
+  }
+  return null
+}
+
+/**
+ * Which of `bindings` the name `name` ultimately reaches. `'rest'` for the
+ * destructured rest binding, `'props'` for the whole props object, `null`
+ * for anything else.
  *
  * The single definition of "this `{...spread}` forwards the caller's
  * leftover props", shared by the two phases that must agree on it: Phase 1
@@ -96,26 +163,15 @@ export interface RestSpreadBindings {
  * `spreadAttrs({...})` merge. Two copies of the rule would let an element
  * qualify for one and not the other, which is exactly the silent-drop
  * shape #2754 reports.
- *
- * Walks hop by hop (not a precomputed set) so a multi-hop alias
- * (`const p2 = props; const p3 = p2`) resolves through every link;
- * `visited` guards a constant cycle (`const a = b; const b = a`). A
- * constant whose value isn't a bare identifier on the chain (a real
- * computed object) stops the walk, so a genuinely different spread
- * expression is never mistaken for the rest object.
  */
 export function resolveRestSpreadOriginCore(
   bindings: RestSpreadBindings,
   constantValues: ReadonlyMap<string, string | undefined>,
   name: string,
 ): 'rest' | 'props' | null {
-  const visited = new Set<string>()
-  let current: string | undefined = name.trim()
-  while (current !== undefined && !visited.has(current)) {
+  return resolveAliasOrigin(constantValues, name, (current) => {
     if (bindings.restPropsName && current === bindings.restPropsName) return 'rest'
     if (bindings.propsObjectName && current === bindings.propsObjectName) return 'props'
-    visited.add(current)
-    current = constantValues.get(current)?.trim()
-  }
-  return null
+    return null
+  })
 }

package/src/types.ts

@@ -594,7 +594,9 @@ export interface IRLoop {
   isStaticArray: boolean
 
   /**
-   * True when the array is a direct prop reference promoted to mapArray (#1586).
+   * True when the array is a direct prop reference promoted to mapArray
+   * (#1586) — including one reached only through a bare `const x = y`
+   * alias-hop chain (`isArrayExprDirectPropRef`, jsx-to-ir.ts, #2724).
    * Adapters use this to include the array in JSON serialization (bf-p)
    * even though isStaticArray is false — the client's mapArray needs the
    * initial data for hydration, unlike signal-backed arrays.
@@ -936,6 +938,19 @@ export interface MapCallbackPreamble {
    * expression subset cannot model leaves this `undefined`, and the Phase-1
    * DSL gate refuses the whole loop with `/* @client *\/` guidance.
    *
+   * ONE exception (#2797): a declaration whose initializer is a function
+   * literal is ELIDED (contributes no entry here) rather than refusing the
+   * preamble, when EVERY read of that name outside its own binding sits
+   * inside an event-handler `JsxAttribute` (`/^on[A-Z]/`) value position —
+   * see `neutralPreambleDeclarations`'s `everyReadIsEventHandlerPropValue`
+   * check. Every DSL adapter's own SSR component-prop builder already skips
+   * an event-handler prop outright, so a name read only that way never needs
+   * an SSR representation; the client-JS preamble (`segments`) still carries
+   * the real closure. This can leave `declarations` a legally EMPTY array
+   * (all-declared names elided) rather than `undefined` — the Phase-1 gate
+   * checks falsiness, and `[]` is truthy, so an empty array reads as "fully
+   * declared, nothing to emit," not a refusal.
+   *
    * Declarations appear in source order and may read earlier ones; adapters
    * emit them in order, so an earlier local is in scope for a later
    * initializer, exactly as in the source.
@@ -1535,10 +1550,9 @@ export interface SignalInfo {
    * `templateCondition` fields on other IR positions. Destructured mode
    * only (`propsObjectName === null`); undefined when no rewrite was
    * needed (no destructured prop referenced) or the component is in
-   * object-props mode (there, `rewritePropsObjectRef`/`applyPropsRewrite`
-   * handle `props.x` → `_p.x` on the final joined/substituted string
-   * instead, since a bare `props.x` textual match works without an
-   * AST-level pre-rewrite).
+   * object-props mode (there, `rewritePropsObjectRef` handles `props.x` →
+   * `_p.x` on the final joined/substituted string instead, since a bare
+   * `props.x` textual match works without an AST-level pre-rewrite).
    */
   templateInitialValue?: string
   /**