@barefootjs/jsx 0.29.0 → 0.30.2

package/src/prop-rewrite.ts

@@ -3,39 +3,165 @@
  *
  * Walks the TypeScript AST to identify destructured prop names used as
  * value references (not as object keys, property access targets, or
- * shorthand properties), then applies targeted regex replacement.
+ * shorthand properties), then splices `_p.` onto exactly those
+ * references in the emitted text via a second scope-aware walk over
+ * the text's own AST.
+ *
+ * Scope model: a name bound INSIDE the expression — a nested arrow /
+ * function parameter, a block-scoped declaration, a catch variable —
+ * refers to that binding, not the prop, for the whole binding's scope.
+ * Both the discovery walk and the rewrite walk carry the same binding
+ * stack, so `items.map((title) => title.a)` never turns into the
+ * syntactically invalid `.map((_p.title) => _p.title.a)` when `title`
+ * is also a prop. (Names bound by loop callbacks that ENCLOSE the
+ * expression are the caller's job — see the `ctx.loopParams` filter in
+ * `jsx-to-ir.ts`'s `rewriteBarePropRefs` wrapper, #2222.)
  */
 
 import ts from 'typescript'
 import { PROPS_PARAM } from './ir-to-client-js/utils.ts'
 import { createTemplateAwareStringProtector } from './ir-to-client-js/html-template.ts'
 
+/** Collect every name introduced by a binding name (identifier or pattern). */
+function collectBindingNames(name: ts.BindingName, out: Set<string>): void {
+  if (ts.isIdentifier(name)) {
+    out.add(name.text)
+    return
+  }
+  for (const el of name.elements) {
+    if (ts.isBindingElement(el)) collectBindingNames(el.name, out)
+  }
+}
+
+/**
+ * Names bound by `n` for its subtree, or null when `n` introduces no
+ * scope. Function-likes bind their parameters (and a function
+ * expression its own name); blocks bind their statement-level
+ * variable/function declarations; catch clauses bind their variable.
+ */
+function scopeFrameOf(n: ts.Node): Set<string> | null {
+  if (ts.isFunctionLike(n)) {
+    const frame = new Set<string>()
+    for (const p of n.parameters) collectBindingNames(p.name, frame)
+    if ((ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n)) && n.name) frame.add(n.name.text)
+    return frame.size > 0 ? frame : null
+  }
+  if (ts.isBlock(n)) {
+    const frame = new Set<string>()
+    for (const st of n.statements) {
+      if (ts.isVariableStatement(st)) {
+        for (const d of st.declarationList.declarations) collectBindingNames(d.name, frame)
+      } else if (ts.isFunctionDeclaration(st) && st.name) {
+        frame.add(st.name.text)
+      }
+    }
+    return frame.size > 0 ? frame : null
+  }
+  if (ts.isCatchClause(n) && n.variableDeclaration) {
+    const frame = new Set<string>()
+    collectBindingNames(n.variableDeclaration.name, frame)
+    return frame.size > 0 ? frame : null
+  }
+  return null
+}
+
+/**
+ * Depth-first walk that maintains the binding stack described above and
+ * reports every identifier along with whether a binding within `root`
+ * currently shadows it.
+ */
+function walkWithScope(
+  root: ts.Node,
+  visit: (ident: ts.Identifier, parent: ts.Node | undefined, shadowed: boolean) => void,
+): void {
+  const scopeStack: Set<string>[] = []
+  const isShadowed = (name: string) => scopeStack.some(frame => frame.has(name))
+  function rec(n: ts.Node, parent?: ts.Node) {
+    const frame = scopeFrameOf(n)
+    if (frame) scopeStack.push(frame)
+    if (ts.isIdentifier(n)) visit(n, parent, isShadowed(n.text))
+    ts.forEachChild(n, child => rec(child, n))
+    if (frame) scopeStack.pop()
+  }
+  rec(root)
+}
+
+/**
+ * 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.
+ */
+function isNonValuePosition(n: ts.Identifier, parent: ts.Node | undefined): boolean {
+  if (!parent) return false
+  if (ts.isPropertyAssignment(parent) && parent.name === n) return true
+  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.isTypeReferenceNode(parent)) return true
+  return false
+}
+
 /**
  * Walk an AST node for destructured-prop value references and add
  * each found name to `out`. Same skip rules as the rewrite path —
- * object-literal keys, shorthand properties, and property-access
- * names are excluded so only true value references get picked up.
- * Exported for callers that need the raw discovery set (e.g. the
- * branch-local prop-dep cache from #1425).
+ * object-literal keys, shorthand properties, property-access names,
+ * and names shadowed by a binding inside `node` are excluded so only
+ * true value references get picked up. Exported for callers that need
+ * the raw discovery set (e.g. the branch-local prop-dep cache from
+ * #1425).
  */
 export function collectAstPropRefs(
   node: ts.Node,
   propNames: Set<string>,
   out: Set<string>,
 ): void {
-  function visit(n: ts.Node, parent?: ts.Node) {
-    if (ts.isIdentifier(n) && propNames.has(n.text)) {
-      // Skip: object literal key  { org: ... }
-      if (parent && ts.isPropertyAssignment(parent) && parent.name === n) return
-      // Skip: shorthand property  { org }
-      if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === n) return
-      // Skip: property access name  foo.org
-      if (parent && ts.isPropertyAccessExpression(parent) && parent.name === n) return
-      out.add(n.text)
+  walkWithScope(node, (n, parent, shadowed) => {
+    if (shadowed || !propNames.has(n.text)) return
+    if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === n) return
+    if (isNonValuePosition(n, parent)) return
+    out.add(n.text)
+  })
+}
+
+/**
+ * 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.
+ *
+ * Returns null when `text` does not parse cleanly as an expression —
+ * the caller falls back to the legacy regex rewrite.
+ */
+function applyScopedPropRefRewrite(text: string, propRefs: Set<string>): 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
+
+  const edits: Array<{ start: number; end: number; replacement: string }> = []
+  walkWithScope(sf, (n, parent, shadowed) => {
+    if (shadowed || !propRefs.has(n.text)) return
+    if (isNonValuePosition(n, parent)) return
+    const start = n.getStart(sf) - prefix.length
+    const end = n.getEnd() - prefix.length
+    if (start < 0 || end > text.length) return
+    if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === n) {
+      edits.push({ start, end, replacement: `${n.text}: ${PROPS_PARAM}.${n.text}` })
+      return
     }
-    ts.forEachChild(n, child => visit(child, n))
+    edits.push({ start, end, replacement: `${PROPS_PARAM}.${n.text}` })
+  })
+
+  if (edits.length === 0) return text
+  let result = text
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, edit.start) + edit.replacement + result.slice(edit.end)
   }
-  visit(node)
+  return result
 }
 
 /**
@@ -43,6 +169,10 @@ export function collectAstPropRefs(
  * type-stripped expression text. Idempotent under `_p.X` (negative
  * lookbehind on `_p\\.`) and skips object-literal keys via the
  * post-match `{,` + `:` shape check.
+ *
+ * Legacy fallback for text that doesn't parse as a standalone
+ * expression — it cannot see scopes, so `applyScopedPropRefRewrite`
+ * is always tried first.
  */
 export function applyRegexPropRefRewrite(
   text: string,
@@ -77,8 +207,8 @@ export function applyRegexPropRefRewrite(
  * @param extraPropRefs - Optional prop names known to appear in
  *   `text` via substitution sources the AST walk can't see (e.g.
  *   `text` was produced by inlining a branch-local whose initializer
- *   references the prop). The post-match `_p\\.` lookbehind keeps
- *   the regex idempotent, so passing an over-broad set is safe.
+ *   references the prop). The rewrite only touches genuine value
+ *   references, so passing an over-broad set is safe.
  */
 export function rewriteBarePropRefs(
   text: string,
@@ -95,5 +225,5 @@ export function rewriteBarePropRefs(
     }
   }
   if (foundPropRefs.size === 0) return undefined
-  return applyRegexPropRefRewrite(text, foundPropRefs)
+  return applyScopedPropRefRewrite(text, foundPropRefs) ?? applyRegexPropRefRewrite(text, foundPropRefs)
 }

package/src/rich-type-evidence.ts

@@ -69,13 +69,12 @@ type EvidenceMetadata = Pick<IRMetadata, 'propsType' | 'propsObjectName' | 'prop
  * check callers gate on).
  */
 function isNullishArm(t: TypeInfo): boolean {
-  if (t.kind === 'primitive' && (t.primitive === 'null' || t.primitive === 'undefined')) return true
-  // `null` as a type annotation is a `ts.LiteralTypeNode` (not the
-  // `NullKeyword` `typeNodeToTypeInfo`'s primitive switch checks for), so it
-  // falls through to `{ kind: 'unknown', raw: 'null' }` there — a pre-existing
-  // gap in that shared helper, out of scope to fix here. Match on `raw` too
-  // so `Date | null` still strips down to `Date`.
-  return t.kind === 'unknown' && (t.raw === 'null' || t.raw === 'undefined')
+  // Purely structural: `typeNodeToTypeInfo`'s literal-type arm lowers a
+  // `null` union member (`ts.LiteralTypeNode(NullKeyword)`) to
+  // `{ kind: 'primitive', primitive: 'null' }`, the same shape a bare
+  // `null` annotation always produced — the raw-text fallback this helper
+  // used to carry for the analyzer gap is gone with the gap.
+  return t.kind === 'primitive' && (t.primitive === 'null' || t.primitive === 'undefined')
 }
 
 export function stripUnion(type: TypeInfo | null): TypeInfo | null {

package/src/ssr-defaults.ts

@@ -107,15 +107,20 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
   //     wins via `propName`).
   for (const p of metadata.propsParams) {
     if (p.isRest) continue
+    // `propName` is the CALLER-facing key (`$props->{propName}` in the Perl
+    // consumer above) — for a renaming destructure (`{ n: count }`) that's
+    // `n`, not the local binding `count` the template variable is keyed by.
+    // `sourceName ?? name` is an identity for every un-aliased prop.
+    const callerPropName = p.sourceName ?? p.name
     if (metadata.propsObjectName === null && p.defaultValue !== undefined) {
       const value = tryStaticEval(p.defaultValue, { bindings: {}, propsLike })
-      out[p.name] = { propName: p.name, value: resultToJsonable(value) }
+      out[p.name] = { propName: callerPropName, value: resultToJsonable(value) }
     } else {
       // No destructure default — the template reads the prop as-is;
       // Perl's `//` operator decides what `undef` becomes. The entry
       // still matters so the template variable exists and consumers
       // can supply the propName even with no static fallback.
-      out[p.name] = { propName: p.name, value: null }
+      out[p.name] = { propName: callerPropName, value: null }
     }
   }
   // Rest-props bag (`...props`) — tracked separately from `propsParams`

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

@@ -393,8 +393,14 @@ function deriveFormat(locale: string, probeOptions: Record<string, string>): Loc
  */
 /** A quoted string-literal union member's value, or null when the member is anything else. */
 function unionMemberLiteral(member: TypeInfo): string | null {
-  const m = /^'([^'\\]*)'$|^"([^"\\]*)"$/.exec(member.raw.trim())
-  return m ? (m[1] ?? m[2]) : null
+  // Structural since the analyzer's literal-type arm: a string-literal
+  // member is `kind: 'primitive', primitive: 'string'` carrying its value
+  // in `literalValue`. (Previously regexed `member.raw` because literal
+  // members lowered to `kind: 'unknown'`.)
+  if (member.kind === 'primitive' && member.primitive === 'string' && member.literalValue !== undefined) {
+    return member.literalValue
+  }
+  return null
 }
 
 /**

package/src/types.ts

@@ -60,6 +60,13 @@ export interface TypeInfo {
   // For primitives
   primitive?: 'string' | 'number' | 'boolean' | 'null' | 'undefined'
 
+  /** Set when the type is a LITERAL of its primitive family (`'a'`, `42`,
+   *  `true`) — the literal's source value. `typeNodeToTypeInfo` lowers a
+   *  literal type to `kind: 'primitive'` + this field, so family-only
+   *  consumers need no special case and value consumers never re-parse
+   *  `raw`. */
+  literalValue?: string
+
   // For objects/interfaces
   properties?: PropertyInfo[]
 
@@ -854,6 +861,28 @@ export interface MapCallbackPreamble {
   ssrText: TsxSourceText
   /** const/let/function names the preamble declares (D5 key-derivability guard). */
   declaredNames: string[]
+  /**
+   * The whole preamble as backend-neutral value declarations — set only when
+   * EVERY statement is one (#2447). This is the DSL SSR carrier: a template
+   * language cannot execute `segments` (that is JS text, for the client bundle
+   * and for JS-runtime SSR), but it CAN declare a per-row local, and each
+   * declaration's initializer is a {@link ParsedExpr} every adapter already
+   * knows how to emit in its own syntax — the same door `arrayParsed` /
+   * `filterPredicate.predicate` / `sortComparator` go through.
+   *
+   * All-or-nothing on purpose. A preamble is a statement SEQUENCE with
+   * order-dependent scope; lowering the declarable prefix and dropping the rest
+   * would leave later statements' effects missing with no diagnostic — the
+   * silent divergence #2447 was. So one non-declaration statement (an
+   * assignment, a loop, a call for side effects) or one initializer the
+   * expression subset cannot model leaves this `undefined`, and the Phase-1
+   * DSL gate refuses the whole loop with `/* @client *\/` guidance.
+   *
+   * 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.
+   */
+  declarations?: PreambleValueDeclaration[]
   /**
    * The subset of {@link declaredNames} that accumulate JSX leaves — the
    * `push`/`unshift` targets of a `jsx` segment and the declaration targets of
@@ -864,6 +893,25 @@ export interface MapCallbackPreamble {
   builderNames: string[]
 }
 
+/**
+ * One `const`/`let` value declaration from a `.map()` callback preamble, in
+ * backend-neutral form (#2447 — see {@link MapCallbackPreamble.declarations}).
+ * `name` is always a simple identifier: a destructuring binding declares
+ * several names from one initializer, which no adapter has a single per-row
+ * local form for, so that shape refuses instead of being carried here.
+ */
+export interface PreambleValueDeclaration {
+  /** Declared local name (simple identifier binding). */
+  name: string
+  /** Initializer, structured for per-adapter emission. */
+  valueParsed: ParsedExpr
+  /**
+   * Initializer source text, for a diagnostic that needs to quote it. Never an
+   * emission input — emission goes through `valueParsed`.
+   */
+  raw: string
+}
+
 /**
  * One loop-body expression child classified as a preamble-patched region
  * (#2389 — see `IRLoop.preambleRegions`). `expr` is the raw (unwrapped)
@@ -1002,6 +1050,20 @@ export interface IRComponent {
    * Omitted (undefined) for ordinary components to keep IR diffs minimal.
    */
   dynamicTag?: boolean
+  /**
+   * True when this component is a DIRECT member of an `IRLoop.children`
+   * array (the loop's row-root component, e.g. `{rows().map(r => <Row/>)}`).
+   * Such a component owns its own per-row identity and gets a freshly
+   * randomized `bf-s` — it does NOT derive its scope id from the parent
+   * scope + mount slot the way an ordinarily-slotted child does.
+   *
+   * A component nested *below* the row root (e.g. `<li><Badge/></li>` where
+   * `<li>` is the loop row root) is NOT marked — it derives its scope id
+   * from parent scope + slot like any other slotted child. See
+   * `derivesScopeFromSlot` in `./adapters/child-scope.ts`, which is the one
+   * predicate every backend must consult instead of re-deriving this fact.
+   */
+  loopItemRoot?: boolean
   loc: SourceLocation
 }
 
@@ -1399,6 +1461,15 @@ export interface SignalInfo {
    * AST-level pre-rewrite).
    */
   templateInitialValue?: string
+  /**
+   * True for the getter-elided declaration form `const [, setX] =
+   * createSignal(...)`. `getter` then holds a synthesized internal name
+   * (`__bfGet_<setter>`) that no expression ever references — it exists so
+   * getter-keyed consumers (substitution env, SSR seeding) stay total.
+   * Emit reproduces the source's `[, setter]` hole instead of introducing
+   * the synthesized name into output.
+   */
+  getterElided?: boolean
   type: TypeInfo
   loc: SourceLocation
   /**
@@ -1458,6 +1529,15 @@ export interface SignalInfo {
 export interface MemoInfo {
   name: string
   computation: string
+  /**
+   * `computation` with bare destructured-prop refs rewritten to `_p.X` —
+   * the memo twin of `SignalInfo.templateInitialValue` (#2265). Consumed by
+   * `buildSignalMemoEnv` when the memo body is inlined into the module-scope
+   * CSR `template:` arrow, which is not a closure over init's destructured
+   * extractions (#2468). Only set for destructured-arg components that
+   * actually reference a prop.
+   */
+  templateComputation?: string
   /** Computation with TypeScript type annotations preserved, for .tsx output */
   typedComputation?: string
   /**