@barefootjs/jsx 0.18.5 → 0.19.0

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

@@ -22,6 +22,7 @@ import type {
   ImportInfo,
 } from '../types.ts'
 import type { CsrInlinabilityMap } from './csr-substitute.ts'
+import type { SkeletonSlotPaths } from './html-template.ts'
 
 export interface ClientJsContext {
   componentName: string
@@ -404,6 +405,18 @@ export type ConditionalBranchConditional = ConditionalElement
 export interface NestedLoop extends LoopCore {
   kind: 'nested'
   depth: number    // 1 for first nesting level, 2 for second, etc.
+  /**
+   * Index parameter of the inner `.map()` callback (e.g. `i` from
+   * `.map((item, i) => ...)`), or `null` when the callback doesn't declare
+   * one. Mirrors `TopLevelLoop.index` / `BranchLoop.index` — added by #2218
+   * so a nested loop's `key`/reactive-text/reactive-attr/template/event/ref
+   * expressions that reference the index can be bound instead of throwing
+   * `ReferenceError` at runtime. The renderItem body only receives the
+   * index as a synthetic `__innerIdx<uid>` positional param (to avoid
+   * cross-depth name collisions), so emitters must alias it under this
+   * name when referenced — see `nestedLoopReferencesIndex` in `shared.ts`.
+   */
+  index: string | null
   containerSlotId: string | null // Slot ID of the parent element containing the loop (for hydration)
   /** HTML template for a single inner loop item (for mapArray CSR rendering) */
   template?: string
@@ -529,6 +542,14 @@ export interface TopLevelLoop extends LoopCore {
    * proven covered by an effect).
    */
   skeletonTemplate?: string
+  /**
+   * Compile-time child-index paths for `skeletonTemplate`'s dynamic slots
+   * (perf, #2143), computed by `computeSkeletonSlotPaths` from the same IR
+   * tree. `undefined` means "resolve every slot via `qsa`/`$t` at runtime"
+   * (skeletonTemplate is still hoisted/cloned — only the runtime lookups on
+   * top of the fresh clone become the fallback rather than the path chain).
+   */
+  skeletonPaths?: SkeletonSlotPaths
   childEventHandlers: string[] // Bare-identifier event handler names (for the reachability graph)
   childComponent?: IRLoopChildComponent // For createComponent-based rendering
   nestedComponents?: IRLoopChildComponent[] // For nested components in loop bodies

package/src/jsx-to-ir.ts

@@ -34,7 +34,7 @@ import {
   AttrValueOf,
 } from './types.ts'
 import { type AnalyzerContext, type MultiReturnJsxInfo, getSourceLocation, collectReactiveGetterNames } from './analyzer-context.ts'
-import { parseExpression, isSupported, parseBlockBody, foldBlockToExpr, predicateTernaryToLogical, tsNodeToParsedExpr, sortComparatorFromArrow, stringifyParsedExpr, cssKebabCase, type ParsedExpr } from './expression-parser.ts'
+import { parseExpression, isSupported, parseBlockBody, foldBlockToExpr, predicateTernaryToLogical, tsNodeToParsedExpr, sortComparatorFromArrow, stringifyParsedExpr, cssKebabCase, CALLBACK_METHODS, type ParsedExpr } from './expression-parser.ts'
 import type { IRLoopSort, FunctionInfo } from './types.ts'
 import { formatParamWithType } from './module-exports.ts'
 import { createError, ErrorCodes, internalInvariant } from './errors.ts'
@@ -291,8 +291,21 @@ function exprHasFunctionCalls(expr: ts.Expression): boolean {
  * Returns undefined if no rewriting is needed (SolidJS-style or no props).
  */
 function rewriteBarePropRefs(text: string, expr: ts.Node, ctx: TransformContext): string | undefined {
-  const propNames = getDestructuredPropNames(ctx)
+  let propNames = getDestructuredPropNames(ctx)
   if (!propNames) return undefined
+  // #2222: a name bound as an enclosing loop callback's item/index param
+  // refers to the loop binding, not the prop, at THIS transform position —
+  // `ctx.loopParams` is the live loop-param set (destructured binding
+  // names and the index included), maintained by `transformMapCall` as it
+  // enters/leaves each callback, so this guard is scope-accurate rather
+  // than the coarse whole-component exclusion the SSR adapters use
+  // (#2221). Filter into a fresh set — `getDestructuredPropNames` caches
+  // its set on ctx and must not be mutated.
+  if (ctx.loopParams.size > 0) {
+    const filtered = new Set([...propNames].filter(n => !ctx.loopParams.has(n)))
+    if (filtered.size === 0) return undefined
+    propNames = filtered
+  }
   // #1425: union any prop refs that `expr` reaches via branch-local
   // text substitution. The AST walk in `rewriteBarePropRefsCore`
   // sees only `expr`'s original AST, so a prop ref introduced via
@@ -591,20 +604,34 @@ function parseValueExpr(trimmed: string): ParsedExpr {
   return parseExpression(trimmed.startsWith('{') ? `(${trimmed})` : trimmed)
 }
 
+/** Shared empty-set default for `attachParsedExpressions`/`resolveCallbackMethodFunctionReferences`'s `bound` param — avoids a fresh allocation per call when nothing is shadowed. */
+const EMPTY_BOUND: ReadonlySet<string> = new Set()
+
 /**
  * Attach `parsed` (`parseExpression(expr.trim())`) to every `expression` node
  * in the tree, so SSR adapters emit from the structured tree instead of each
  * re-parsing the string at emit time. Best-effort: a node this walk misses (or
  * an empty `expr`) simply has no `parsed`, and the adapter falls back to
  * parsing — so under-coverage is safe, never a behavioural change.
+ *
+ * Every parse is run through {@link resolveCallbackMethodFunctionReferences}
+ * (#2206) so a bare-identifier `.map`/`.filter`/… callback (`tags.map(format)`)
+ * resolves to its declaration wherever it can appear — text/attr/prop/provider
+ * expressions and the loop-array expression alike — not just one hardcoded
+ * spot. `bound` carries the enclosing loop(s)' `param`/`index` names down
+ * into that resolution (Fable review, #2214) so a loop item variable that
+ * happens to share a name with a module-scope const/function shadows it,
+ * same as real JS scoping — resolution stays off within that loop's body.
  */
-function attachParsedExpressions(node: IRNode): void {
+function attachParsedExpressions(node: IRNode, analyzer: AnalyzerContext, bound: ReadonlySet<string> = EMPTY_BOUND): void {
+  const parse = (trimmed: string) => resolveCallbackMethodFunctionReferences(parseExpression(trimmed), analyzer, bound)
+  const parseValue = (trimmed: string) => resolveCallbackMethodFunctionReferences(parseValueExpr(trimmed), analyzer, bound)
   if (node.type === 'expression') {
     const trimmed = node.expr.trim()
-    if (trimmed) node.parsed = parseExpression(trimmed)
+    if (trimmed) node.parsed = parse(trimmed)
   } else if (node.type === 'conditional' || node.type === 'if-statement') {
     const trimmed = node.condition.trim()
-    if (trimmed) node.parsedCondition = parseExpression(trimmed)
+    if (trimmed) node.parsedCondition = parse(trimmed)
   }
   // Attach `parsed` to every expression-valued attribute / prop so adapters can
   // lower from the tree instead of re-parsing the string. Element attrs,
@@ -615,23 +642,23 @@ function attachParsedExpressions(node: IRNode): void {
     for (const attr of node.attrs) {
       if (attr.value.kind === 'expression') {
         const trimmed = attr.value.expr.trim()
-        if (trimmed) attr.value.parsed = parseValueExpr(trimmed)
+        if (trimmed) attr.value.parsed = parseValue(trimmed)
       } else if (attr.value.kind === 'spread') {
         const trimmed = attr.value.expr.trim()
-        if (trimmed) attr.value.parsed = parseExpression(trimmed)
+        if (trimmed) attr.value.parsed = parse(trimmed)
       }
     }
   } else if (node.type === 'component') {
     for (const prop of node.props) {
       if (prop.value.kind === 'expression') {
         const trimmed = prop.value.expr.trim()
-        if (trimmed) prop.value.parsed = parseValueExpr(trimmed)
+        if (trimmed) prop.value.parsed = parseValue(trimmed)
       }
     }
   } else if (node.type === 'provider') {
     if (node.valueProp.value.kind === 'expression') {
       const trimmed = node.valueProp.value.expr.trim()
-      if (trimmed) node.valueProp.value.parsed = parseValueExpr(trimmed)
+      if (trimmed) node.valueProp.value.parsed = parseValue(trimmed)
     }
   }
   switch (node.type) {
@@ -639,46 +666,54 @@ function attachParsedExpressions(node: IRNode): void {
     case 'component':
     case 'fragment':
     case 'provider':
-      for (const child of node.children) attachParsedExpressions(child)
+      for (const child of node.children) attachParsedExpressions(child, analyzer, bound)
       break
     case 'async':
-      attachParsedExpressions(node.fallback)
-      for (const child of node.children) attachParsedExpressions(child)
+      attachParsedExpressions(node.fallback, analyzer, bound)
+      for (const child of node.children) attachParsedExpressions(child, analyzer, bound)
       break
     case 'loop': {
       // Attach the parse of the SAME `array` string the adapters consume
       // (the Go adapter's scalar-literal loop typing reads `loop.array` /
       // `nested.loopArray`, which is exactly `loop.array`), so it can read
-      // the tree instead of re-parsing with `ts.createSourceFile`.
+      // the tree instead of re-parsing with `ts.createSourceFile`. The array
+      // expression itself is evaluated in the OUTER scope (before the loop's
+      // own `param`/`index` exist), so it parses against the unextended `bound`.
       const trimmedArray = node.array.trim()
-      if (trimmedArray) node.arrayParsed = parseExpression(trimmedArray)
-      for (const child of node.children) attachParsedExpressions(child)
+      if (trimmedArray) node.arrayParsed = parse(trimmedArray)
+      // The loop's item/index variables shadow any same-named module-scope
+      // const/function for everything inside the loop body (Fable review,
+      // #2214) — mirrors an arrow's own params in `resolveCallbackMethodFunctionReferences`.
+      const loopBound = new Set(bound)
+      loopBound.add(node.param)
+      if (node.index) loopBound.add(node.index)
+      for (const child of node.children) attachParsedExpressions(child, analyzer, loopBound)
       // Loops also hold expression nodes off the main `children` array.
       if (node.childComponent) {
-        for (const child of node.childComponent.children) attachParsedExpressions(child)
+        for (const child of node.childComponent.children) attachParsedExpressions(child, analyzer, loopBound)
       }
       for (const nested of node.nestedComponents ?? []) {
-        for (const child of nested.children) attachParsedExpressions(child)
+        for (const child of nested.children) attachParsedExpressions(child, analyzer, loopBound)
       }
       for (const frag of node.flatMapCallback?.fragments ?? []) {
-        attachParsedExpressions(frag.ir)
+        attachParsedExpressions(frag.ir, analyzer, loopBound)
       }
       break
     }
     case 'conditional':
-      attachParsedExpressions(node.whenTrue)
-      attachParsedExpressions(node.whenFalse)
+      attachParsedExpressions(node.whenTrue, analyzer, bound)
+      attachParsedExpressions(node.whenFalse, analyzer, bound)
       break
     case 'if-statement':
-      attachParsedExpressions(node.consequent)
-      if (node.alternate) attachParsedExpressions(node.alternate)
+      attachParsedExpressions(node.consequent, analyzer, bound)
+      if (node.alternate) attachParsedExpressions(node.alternate, analyzer, bound)
       break
   }
 }
 
 export function jsxToIR(analyzer: AnalyzerContext): IRNode | null {
   const root = buildIRRoot(analyzer)
-  if (root) attachParsedExpressions(root)
+  if (root) attachParsedExpressions(root, analyzer)
   return root
 }
 
@@ -2632,8 +2667,8 @@ function extractSortComparator(
  * vs. unresolved) is decided by the caller, not here.
  */
 function resolveSortComparatorIdentifier(name: string, ctx: TransformContext): ts.Expression | null {
-  const constInfo = findLocalConst(name, ctx)
-  const fnInfo = findLocalFunction(name, ctx)
+  const constInfo = findLocalConst(name, ctx.analyzer)
+  const fnInfo = findLocalFunction(name, ctx.analyzer)
   if (constInfo && fnInfo) return null
   if (constInfo) {
     const ast = parseConstInitializer(constInfo)
@@ -2646,6 +2681,149 @@ function resolveSortComparatorIdentifier(name: string, ctx: TransformContext): t
   return null
 }
 
+/**
+ * Resolve a bare-identifier callback passed to a value-position higher-order
+ * array method (`tags.map(format)`, `.filter`, `.sort`, … — any name in
+ * {@link CALLBACK_METHODS}, #2206) to its underlying arrow / function-
+ * expression node — the SAME one-hop, ambiguity-refuses lookup #2090
+ * established for `.sort(fnref)` comparators (`resolveSortComparatorIdentifier`
+ * above). Kept as its own small function (mirroring the existing
+ * `resolveInterleaveTagIdentifier` precedent below) rather than sharing code
+ * with the sort resolver, so each call site's refusal semantics stay
+ * independently reviewable.
+ *
+ * Only needs `AnalyzerContext` (not a full `TransformContext`) because its
+ * caller, {@link resolveCallbackMethodFunctionReferences}, runs as a
+ * post-parse pass over an already-built `ParsedExpr` tree — no live
+ * `ts.Node`/source-file binding is available or needed, since
+ * `parseConstInitializer` / `parseFunctionInfoAsExpr` re-parse the
+ * analyzer's stored declaration TEXT into a fresh, isolated source file.
+ */
+function resolveCallbackMethodFunctionReferenceIdentifier(name: string, analyzer: AnalyzerContext): ts.Expression | null {
+  const constInfo = findLocalConst(name, analyzer)
+  const fnInfo = findLocalFunction(name, analyzer)
+  if (constInfo && fnInfo) return null
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo)
+    return ast && (ts.isArrowFunction(ast) || ts.isFunctionExpression(ast)) ? ast : null
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo)
+    return ast && (ts.isArrowFunction(ast) || ts.isFunctionExpression(ast)) ? ast : null
+  }
+  return null
+}
+
+/**
+ * Post-parse pass (#2206): walk a `ParsedExpr` tree and resolve every
+ * `<recv>.<CALLBACK_METHODS method>(<bare identifier>, …rest)` call's
+ * callback argument to its declaration, so `tags.map(format).join(' ')`
+ * compiles exactly as if `format`'s body had been written inline
+ * (`tags.map(t => '#' + t).join(' ')`) — the shape `asCallbackMethodCall`
+ * (expression-parser.ts) already recognizes and every adapter's `map_eval`
+ * (#2073) already lowers.
+ *
+ * Runs AFTER `parseExpression`, not threaded into it, because the
+ * value-returning `.map(cb)` form is recognized generically downstream of
+ * parsing (`asCallbackMethodCall`'s `arrow.kind !== 'arrow'` check), not
+ * during it — `convertNode` already happily produces a generic `call` node
+ * with an `identifier` arg for `tags.map(format)` with no special-casing
+ * needed there. An unresolvable reference (import, non-function const,
+ * alias chain, cross-kind ambiguity — see
+ * {@link resolveCallbackMethodFunctionReferenceIdentifier}) or a resolved
+ * body that can't fold to a single expression is left untouched: the
+ * `identifier` arg passes through as-is, and `asCallbackMethodCall`'s
+ * existing arrow-kind check still refuses it with the current BF101,
+ * unchanged.
+ *
+ * A spliced-in resolved arrow's OWN body is not re-walked (`visit` returns
+ * it as-is rather than recursing) — a bare-identifier callback declared
+ * INSIDE another resolved declaration (`const outer = xs => xs.map(inner).join(',')`
+ * used as `rows.map(outer)`) stays unresolved and BF101-refuses, same as
+ * before #2206. This is a deliberate one-hop limit, not an oversight: naively
+ * recursing risks an infinite loop on a self-referential declaration
+ * (`const f = xs => xs.map(f)`), which would need a resolution stack to
+ * detect — out of scope here. Fails safe (refuses loudly rather than
+ * mis-rendering); see the pinned-refusal test in map-function-reference.test.ts.
+ *
+
+ * `bound` tracks names that are lexically shadowed at the current walk
+ * position — an enclosing arrow's own params (`rows.map(fn => fn.tags.map(fn)…)`
+ * — so a bare identifier that refers to a PARAMETER rather than a same-file
+ * const/function is never resolved against the const/function tables
+ * (Fable review, #2214): it grows exactly like {@link freeVarsInBody}'s own
+ * `bound` set, at the SAME `arrow` case. The initial call from
+ * `attachParsedExpressions` seeds it with the enclosing loop's `param`/
+ * `index` too (a loop's item variable shadows a same-named module const the
+ * same way a callback arrow's param does — `origin.freeRefs` already tags
+ * such a name `kind: 'render-item'`, this walk now honors it).
+ */
+function resolveCallbackMethodFunctionReferences(
+  expr: ParsedExpr,
+  analyzer: AnalyzerContext,
+  bound: ReadonlySet<string> = EMPTY_BOUND,
+): ParsedExpr {
+  function visit(e: ParsedExpr, bound: ReadonlySet<string>): ParsedExpr {
+    switch (e.kind) {
+      case 'literal':
+      case 'identifier':
+      case 'regex':
+      case 'unsupported':
+        return e
+      case 'call': {
+        const callee = visit(e.callee, bound)
+        const args = e.args.map(a => visit(a, bound))
+        if (
+          callee.kind === 'member' && !callee.computed &&
+          CALLBACK_METHODS.has(callee.property) &&
+          args[0]?.kind === 'identifier' &&
+          !bound.has(args[0].name)
+        ) {
+          const resolved = resolveCallbackMethodFunctionReferenceIdentifier(args[0].name, analyzer)
+          const arrow = resolved ? tsNodeToParsedExpr(resolved) : null
+          if (arrow && arrow.kind === 'arrow') args[0] = arrow
+        }
+        return { ...e, callee, args }
+      }
+      case 'member':
+        return { ...e, object: visit(e.object, bound) }
+      case 'index-access':
+        return { ...e, object: visit(e.object, bound), index: visit(e.index, bound) }
+      case 'binary':
+      case 'logical':
+        return { ...e, left: visit(e.left, bound), right: visit(e.right, bound) }
+      case 'unary':
+        return { ...e, argument: visit(e.argument, bound) }
+      case 'conditional':
+        return { ...e, test: visit(e.test, bound), consequent: visit(e.consequent, bound), alternate: visit(e.alternate, bound) }
+      case 'template-literal':
+        return { ...e, parts: e.parts.map(p => (p.type === 'expression' ? { ...p, expr: visit(p.expr, bound) } : p)) }
+      case 'array-literal':
+        return { ...e, elements: e.elements.map(el => visit(el, bound)) }
+      case 'array-method':
+        // `e.args` is a fixed-length tuple for some `method` variants (e.g.
+        // `flat`'s `args: []`) — `.map(visit)` preserves length/order (a
+        // callback resolution never adds/removes args), so this is a
+        // same-shape cast, not a structural change. TS can't verify the
+        // per-`method` tuple-length invariant across a `.map`, hence the
+        // whole-object cast rather than a narrower one.
+        return {
+          ...e,
+          object: visit(e.object, bound),
+          args: e.args.map(a => visit(a, bound)),
+          ...(e.method === 'flat' && e.depthExpr ? { depthExpr: visit(e.depthExpr, bound) } : {}),
+        } as ParsedExpr
+      case 'object-literal':
+        return { ...e, properties: e.properties.map(p => ({ ...p, value: visit(p.value, bound) })) }
+      case 'arrow': {
+        const inner = e.params.length === 0 ? bound : new Set([...bound, ...e.params])
+        return { ...e, body: visit(e.body, inner) }
+      }
+    }
+  }
+  return visit(expr, bound)
+}
+
 /**
  * Result type for extractFilterPredicate. The predicate is always an expression:
  * a block body is normalized to one via `foldBlockToExpr` +
@@ -3469,14 +3647,19 @@ function transformMapCall(
           setArray(innerSort.array)
         }
       } else {
-        // Simple filter().map()
-        array = ctx.getJS(filterInfo.array)
-        arrayExpr = filterInfo.array
+        // Simple filter().map(). `setArray` (not a bare `array =`
+        // assignment) so `templateArray` carries the `_p.`-rewritten form —
+        // the module-scope `template:` lambda can't see init's destructured
+        // prop locals, and a bare destructured name there threw
+        // `ReferenceError` at runtime (#2222).
+        setArray(filterInfo.array)
       }
     }
   } else {
-    array = ctx.getJS(chainSource)
-    arrayExpr = chainSource
+    // Plain `.map()` fallback — same `setArray` requirement as above
+    // (#2222): this is the most common loop shape and was the primary
+    // repro for the bare-destructured-name ReferenceError.
+    setArray(chainSource)
   }
 
   // Get callback function
@@ -4434,7 +4617,7 @@ function tryResolveTemplateSpanFromConst(
 ): IRTemplatePart[] | null {
   // ${IDENT}
   if (ts.isIdentifier(expr)) {
-    const constInfo = findLocalConst(expr.text, ctx)
+    const constInfo = findLocalConst(expr.text, ctx.analyzer)
     if (!constInfo) return null
     const ast = parseConstInitializer(constInfo)
     if (!ast) return null
@@ -4447,7 +4630,7 @@ function tryResolveTemplateSpanFromConst(
   // ${IDENT[KEY]}
   if (ts.isElementAccessExpression(expr)) {
     if (!ts.isIdentifier(expr.expression)) return null
-    const constInfo = findLocalConst(expr.expression.text, ctx)
+    const constInfo = findLocalConst(expr.expression.text, ctx.analyzer)
     if (!constInfo) return null
     const ast = parseConstInitializer(constInfo)
     if (!ast || !ts.isObjectLiteralExpression(ast)) return null
@@ -4504,8 +4687,8 @@ function tryResolveTemplateSpanFromConst(
  *
  * Returns undefined when no const matches.
  */
-function findLocalConst(name: string, ctx: TransformContext) {
-  const matches = ctx.analyzer.localConstants.filter(c => c.name === name)
+function findLocalConst(name: string, analyzer: AnalyzerContext) {
+  const matches = analyzer.localConstants.filter(c => c.name === name)
   if (matches.length === 0) return undefined
   // Prefer the innermost (non-module) binding; fall back to whatever's
   // there if every match is at module scope.
@@ -4522,8 +4705,8 @@ function findLocalConst(name: string, ctx: TransformContext) {
  *
  * Returns undefined when no local function matches.
  */
-function findLocalFunction(name: string, ctx: TransformContext) {
-  const matches = ctx.analyzer.localFunctions.filter(f => f.name === name)
+function findLocalFunction(name: string, analyzer: AnalyzerContext) {
+  const matches = analyzer.localFunctions.filter(f => f.name === name)
   if (matches.length === 0) return undefined
   const fnScoped = matches.filter(f => !f.isModule)
   const pool = fnScoped.length > 0 ? fnScoped : matches
@@ -4613,7 +4796,15 @@ function tryResolveIdentifierAsTemplateLiteral(
   ident: ts.Identifier,
   ctx: TransformContext,
 ): IRTemplatePart[] | null {
-  const constInfo = findLocalConst(ident.text, ctx)
+  // #2222/#2235: at this transform position the identifier may be an
+  // enclosing loop callback's own (shadowing) parameter — folding the
+  // outer const's literal into the IR here bakes the same hard-coded
+  // value into EVERY adapter's output (e.g. `key={label}` inside
+  // `.map((label) => ...)` becoming a constant duplicate key).
+  // `ctx.loopParams` is the live loop-param set (destructured binding
+  // names and index included), so the guard is scope-accurate.
+  if (ctx.loopParams.has(ident.text)) return null
+  const constInfo = findLocalConst(ident.text, ctx.analyzer)
   if (!constInfo) return null
   const ast = parseConstInitializer(constInfo)
   if (!ast) return null
@@ -4823,8 +5014,8 @@ function tryDesugarInterleaveTaggedTemplate(
  * followed, matching that precedent. Returns null when nothing resolves.
  */
 function resolveInterleaveTagIdentifier(name: string, ctx: TransformContext): ts.Expression | null {
-  const constInfo = findLocalConst(name, ctx)
-  const fnInfo = findLocalFunction(name, ctx)
+  const constInfo = findLocalConst(name, ctx.analyzer)
+  const fnInfo = findLocalFunction(name, ctx.analyzer)
   // A name bound BOTH as a const and as a `function` declaration is the
   // same cross-kind ambiguity `resolveSortComparatorIdentifier` refuses:
   // it can only occur across scopes, and `FunctionInfo.isModule` reflects

package/src/signal-init-eval.ts

@@ -0,0 +1,165 @@
+/**
+ * TEST-HARNESS ONLY. Evaluate a signal initializer / prop-default source
+ * expression against a mock `props` object by EXECUTING it (`new
+ * Function`, with `undefined` shadowing the globals listed below), the
+ * same way the Hono/CSR conformance reference produces its value — by
+ * actually running the component. Never call this from a build path (`bf
+ * build`, `compileJSX`, any adapter's `generate`); it exists only so each
+ * adapter's `test-render.ts` conformance harness can seed a signal/
+ * prop-default for a non-JS-runtime SSR render (PHP/Ruby/Python/Perl/Go)
+ * that matches what Hono would compute. (#2209)
+ *
+ * NOT a security sandbox — the global shadowing below is a determinism
+ * tripwire (catches the common accidental-nondeterminism case, e.g.
+ * `Date.now()`), not containment: a sufficiently creative expression can
+ * still reach the real global scope (`new Function` bodies execute
+ * unlexically-scoped, so e.g. `[].constructor.constructor('return
+ * Date')()` recovers `Date` even though the bare name is shadowed, and
+ * `eval` can't be shadowed at all — JS forbids declaring or binding a
+ * parameter literally named `eval` in strict-mode code). Do not widen this
+ * module's use to anything but first-party fixture source. The actual
+ * trust boundary is that the evaluated text is first-party fixture
+ * source, already compiled by this same process — the conformance harness
+ * already executes fixture-derived code far more invasively (spawning
+ * `ruby`/`php`/`perl`/`go run` on generated programs). This module is
+ * never reachable from anything a real end user's untrusted input could
+ * influence.
+ *
+ * Why real execution instead of a hand-rolled evaluator: the initializer
+ * source is an arbitrary JS-subset expression over `props` (e.g. `(props.x
+ * ?? []).map(t => ({ ...t, editing: false }))`, #2209's actual repro) —
+ * every previous approach here was a regex/pattern-match over a small
+ * catalogue of recognized shapes (`props.x`, `props.x ?? default`, a bare
+ * literal), and #2209 is literally "the catalogue missed a shape" (the
+ * THIRD such miss on this codebase, per the superseded
+ * `evaluate-signal-init.test.ts`'s own #1672 pins). A hand-written
+ * evaluator over `ParsedExpr` would face the same drift, and can't
+ * represent object spread (`{ ...t, editing: false }`) without extending
+ * `ParsedExpr` — a production-compiler change that ripples into every
+ * adapter's exhaustive switch, disproportionate for a test-only need.
+ * `new Function` delegates parsing to the JS engine itself — CLAUDE.md's
+ * regex-parsing ban exists precisely to avoid the false-match/missed-shape
+ * failure mode this replaces.
+ *
+ * Shadowed as `undefined` (best-effort determinism, not containment — see
+ * above): `globalThis`, `window`, `document`, `Date`, `Math`, `crypto`,
+ * `performance`, `fetch`, `setTimeout`, `setInterval`, `require`,
+ * `process`, `Function`. (`eval` is deliberately absent from this list —
+ * it cannot be shadowed as a parameter name in strict-mode code; see
+ * above.)
+ *
+ * `props` bare-identifier destructured params (`createSignal(count)` where
+ * `count` is a destructured prop, not a `props.x` member) are NOT bound —
+ * the evaluator only exposes `props` — so such an initializer throws
+ * `ReferenceError` and falls back to "unset", matching every prior
+ * evaluator's behavior for that shape. Extending the environment with
+ * `ir.metadata.propsParams` bindings is a natural follow-up if a fixture
+ * ever needs it.
+ */
+
+const BLOCKED_GLOBALS = [
+  'globalThis',
+  'window',
+  'document',
+  'Date',
+  'Math',
+  'crypto',
+  'performance',
+  'fetch',
+  'setTimeout',
+  'setInterval',
+  'require',
+  'process',
+  'Function',
+] as const
+
+export type SignalInitEvalResult = { ok: true; value: unknown } | { ok: false }
+
+/**
+ * A value the harness's downstream language serializers (JSON/Python/PHP/
+ * Perl/Ruby literal builders) can actually marshal: `null`, a boolean, a
+ * number (including non-finite — several serializers already special-case
+ * NaN/Infinity), a string, a dense array with no holes and no `undefined`
+ * elements, or a plain object (`Object.prototype` or null prototype only —
+ * rejects class instances, functions, Maps/Sets, etc). Rejects genuine
+ * cycles; a shared (non-cyclic) reference appearing more than once — e.g.
+ * the same object at two array indices — is fine (JSON-equivalent
+ * behavior just duplicates it), so `ancestors` tracks only the current
+ * recursion path, not every value ever visited.
+ */
+function isTransportable(value: unknown, ancestors: Set<unknown> = new Set()): boolean {
+  if (value === null) return true
+  const t = typeof value
+  if (t === 'boolean' || t === 'number' || t === 'string') return true
+  if (t !== 'object') return false
+  if (ancestors.has(value)) return false // a real cycle (value is its own ancestor)
+  ancestors.add(value)
+  try {
+    if (Array.isArray(value)) {
+      // `Array.prototype.every` silently skips holes (`[1, , 3]`), so a
+      // sparse array would otherwise pass — compare against the own
+      // enumerable key count (holes aren't own keys) to catch that.
+      if (Object.keys(value).length !== value.length) return false
+      return value.every(el => el !== undefined && isTransportable(el, ancestors))
+    }
+    const proto = Object.getPrototypeOf(value)
+    if (proto !== Object.prototype && proto !== null) return false
+    return Object.values(value as Record<string, unknown>).every(v => isTransportable(v, ancestors))
+  } finally {
+    ancestors.delete(value)
+  }
+}
+
+/**
+ * Evaluate `expr` (a JS-subset source expression) against `props`. Returns
+ * `{ ok: false }` when the expression fails to parse, throws at evaluation
+ * time (e.g. a `ReferenceError` for an unbound identifier), or evaluates to
+ * something the downstream serializers can't marshal (see
+ * {@link isTransportable}).
+ */
+export function tryEvaluateSignalInit(
+  expr: string,
+  props?: Record<string, unknown>,
+): SignalInitEvalResult {
+  const src = expr.trim()
+  if (src === '') return { ok: false }
+  let fn: (props: Record<string, unknown>, ...blocked: undefined[]) => unknown
+  try {
+    // `props` plus the blocked-globals shadows are the only bindings
+    // passed in — best-effort determinism, not containment; see the file
+    // docstring for the trust-boundary rationale (test-harness-only,
+    // never a build path).
+    fn = new Function(
+      'props',
+      ...BLOCKED_GLOBALS,
+      `'use strict'; return (\n${src}\n);`,
+    ) as typeof fn
+  } catch {
+    return { ok: false }
+  }
+  try {
+    const value = fn(props ?? {})
+    // `undefined` at the TOP level is a genuine, distinguishable result
+    // (e.g. an explicit `undefined` initializer, or `props.x` with no `x`
+    // and no `??` fallback) — not a marshal failure. `evaluateSignalInit`'s
+    // wrapper still collapses it to the "skip" outcome; callers that need
+    // the distinction use this function directly.
+    if (value === undefined) return { ok: true, value: undefined }
+    return isTransportable(value) ? { ok: true, value } : { ok: false }
+  } catch {
+    return { ok: false }
+  }
+}
+
+/**
+ * Drop-in replacement for the harnesses' former per-adapter regex
+ * evaluator: `null` means "could not evaluate, or evaluated to
+ * `undefined` — leave the signal/default unseeded", matching every prior
+ * evaluator's convention (an explicit JS `null` initializer also maps to
+ * `null` — the same "skip" outcome, since none of these harnesses
+ * distinguish "explicitly null" from "unset" downstream).
+ */
+export function evaluateSignalInit(expr: string, props?: Record<string, unknown>): unknown {
+  const result = tryEvaluateSignalInit(expr, props)
+  return result.ok && result.value !== undefined ? result.value : null
+}