@barefootjs/jsx 0.16.0 → 0.17.0

package/src/__tests__/unsupported-expression.test.ts

@@ -216,10 +216,11 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     expect(bf021[0].message).toContain('not a supported shape')
   })
 
-  test('emits BF021 error for multi-statement block-body sort comparator', () => {
-    // Single-`return` block bodies now lower (#1448 Tier B follow-up),
-    // but multi-statement / local-var bodies stay refused — generalising
-    // over arbitrary statement sequences isn't tractable in a template.
+  test('no BF021 for let-inline block-body sort comparator (#2040)', () => {
+    // #2040: a value-producing block body (pure `const` bindings + a terminal
+    // `return`) normalises to a single expression via let-inline, so a
+    // `{ const x = a.price; return x - b.price }` comparator now lowers exactly
+    // like the expression-bodied `(a, b) => a.price - b.price`.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -239,6 +240,32 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     const { errors } = compileToIR(source)
     const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
 
+    expect(bf021).toHaveLength(0)
+  })
+
+  test('emits BF021 error for imperative block-body sort comparator (#2040)', () => {
+    // An imperative comparator (local re-assignment / mutation) has no
+    // value-position lowering — `foldBlockToExpr` refuses it, so the arrow stays
+    // `unsupported` and the sort extraction surfaces BF021.
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        return (
+          <ul>
+            {items().sort((a, b) => { let r = 0; r = a.price - b.price; return r }).map(t => (
+              <li>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
     expect(bf021).toHaveLength(1)
     expect(bf021[0].message).toContain('not a supported shape')
   })
@@ -583,3 +610,70 @@ describe('Rest Pattern in Filter Predicate (BF021, #1532)', () => {
     expect(bf021).toHaveLength(0)
   })
 })
+
+// Block-bodied filter predicates are normalized to a single boolean expression
+// (#2040). A value-producing block lowers like an expression predicate; an
+// imperative block refuses.
+describe('Block-body filter predicate normalization (#2040)', () => {
+  function loopFilterIR(predicate: string) {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        const [filter, setFilter] = createSignal('all')
+        return (
+          <ul>
+            {items().filter(${predicate}).map(t => (
+              <li>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+    const { ir, errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+    // Find the loop node carrying the filterPredicate.
+    let found: any = null
+    const walk = (n: any) => {
+      if (!n || found) return
+      if (n.filterPredicate) found = n
+      for (const c of n.children ?? []) walk(c)
+    }
+    walk(ir)
+    return { bf021, filterPredicate: found?.filterPredicate }
+  }
+
+  test('value-producing block (let-inline + early return) folds to a predicate', () => {
+    const { bf021, filterPredicate } = loopFilterIR(`t => {
+      const f = filter()
+      if (f === 'active') return !t.done
+      if (f === 'completed') return t.done
+      return true
+    }`)
+    expect(bf021).toHaveLength(0)
+    // No leftover block shape — a single boolean predicate expression.
+    expect(filterPredicate?.predicate).toBeDefined()
+    expect((filterPredicate as any)?.blockBody).toBeUndefined()
+  })
+
+  test('signal read on multiple branches still folds (idempotent getter is pure)', () => {
+    const { bf021, filterPredicate } = loopFilterIR(`t => {
+      const f = filter()
+      if (f === 'active') return !t.done
+      return f === 'completed' ? t.done : true
+    }`)
+    expect(bf021).toHaveLength(0)
+    expect(filterPredicate?.predicate).toBeDefined()
+  })
+
+  test('imperative block (local re-assignment) refuses with BF021', () => {
+    const { bf021 } = loopFilterIR(`t => {
+      let keep = false
+      keep = !t.done
+      return keep
+    }`)
+    expect(bf021.length).toBeGreaterThan(0)
+  })
+})

package/src/adapters/env-signal.ts

@@ -10,41 +10,80 @@ import type { ParsedExpr } from '../expression-parser.ts'
 import type { IRMetadata } from '../types.ts'
 
 /**
- * The local binding name(s) that `searchParams` from `@barefootjs/client` is
- * imported under in this component — the same import the analyzer allow-lists
- * (`CLIENT_EXPORTS`). Usually the single name `searchParams`, but an aliased
- * import (`import { searchParams as sp }`) binds it to `sp`, and the template
- * expression then reads `sp()` — so adapters must gate + match against the
- * LOCAL name(s), not the literal `searchParams`. Empty when the env signal is
- * not imported (the component keeps the generic signal lowering).
+ * Env-signal key → the runtime factory that produces it (`'search'` →
+ * `createSearchParams`). Single source of truth for the reverse of the
+ * analyzer's `ENV_SIGNAL_FACTORIES` (#2057): an env signal is `createSignal`-
+ * shaped for analysis, but every backend that re-emits its declaration (client
+ * JS, JSX/Hono SSR) must call this factory, not `createSignal`, so the value is
+ * the request-scoped reader rather than stored state.
+ */
+export const ENV_SIGNAL_CLIENT_FACTORY: Record<string, string> = {
+  search: 'createSearchParams',
+}
+
+/**
+ * The getter name(s) of the `searchParams` env signal in this component.
+ *
+ * Recognised **structurally** (#2057): the env signal is now declared as a
+ * `createSignal`-shaped `const [searchParams, setSearchParams] =
+ * createSearchParams()`, so the analyzer collects it into `metadata.signals`
+ * with `envReader: 'search'` — exactly like any other signal, but tagged. This
+ * function returns those getters (whatever the destructured name is —
+ * `searchParams`, or an alias), so adapters match the reader `.get()` call
+ * against the binding actually used, with **no `searchParams`-name allow-list**
+ * (this supersedes the import-name matching, and the closed #2055).
  *
- * `ImportSpecifier.name` is the exported name and `alias` the local rebinding
- * (see `collectImport` in analyzer.ts), so the import is detected by `name ===
- * 'searchParams'` and the local binding is `alias ?? name`. Namespace / default
- * specifiers bind a different identifier and are excluded.
+ * Empty when the component declares no env signal (the component keeps the
+ * generic signal lowering).
  */
 export function searchParamsLocalNames(metadata: IRMetadata): Set<string> {
   const names = new Set<string>()
-  for (const imp of metadata.imports) {
-    if (imp.source !== '@barefootjs/client' || imp.isTypeOnly) continue
-    for (const s of imp.specifiers) {
-      if (s.isTypeOnly || s.isNamespace || s.isDefault) continue
-      if (s.name === 'searchParams') names.add(s.alias ?? s.name)
-    }
+  for (const s of metadata.signals) {
+    if (s.envReader === 'search') names.add(s.getter)
   }
   return names
 }
 
 /**
- * True when the component imports the `searchParams` env signal under any local
- * name. Convenience for adapters/harnesses that only need to gate on presence
- * (the lowering itself needs the {@link searchParamsLocalNames} set to match the
- * actual binding in the expression).
+ * True when the component declares the `searchParams` env signal. Convenience
+ * for adapters/harnesses that only need to gate on presence (the lowering
+ * itself needs the {@link searchParamsLocalNames} set to match the actual
+ * binding in the expression).
  */
 export function importsSearchParams(metadata: IRMetadata): boolean {
   return searchParamsLocalNames(metadata).size > 0
 }
 
+/**
+ * The local binding name(s) that `queryHref` is imported under in this component
+ * (#2042) — the pure URL-query builder an adapter lowers to its query helper
+ * (`bf_query` in go-template). Matched by the exported name `queryHref` and bound
+ * to `alias ?? name`, so an aliased import (`import { queryHref as qh }`) is gated
+ * against the LOCAL name. Empty when not imported.
+ *
+ * Both the main `@barefootjs/client` entry and the `@barefootjs/client/runtime`
+ * re-export are accepted: `queryHref` is exported from both, so importing it from
+ * either must enable SSR lowering — otherwise the call's object-literal arg would
+ * hit the support gate (BF101) on the runtime-entry import path.
+ */
+export function queryHrefLocalNames(metadata: IRMetadata): Set<string> {
+  const names = new Set<string>()
+  for (const imp of metadata.imports) {
+    if (!QUERY_HREF_SOURCES.has(imp.source) || imp.isTypeOnly) continue
+    for (const s of imp.specifiers) {
+      if (s.isTypeOnly || s.isNamespace || s.isDefault) continue
+      if (s.name === 'queryHref') names.add(s.alias ?? s.name)
+    }
+  }
+  return names
+}
+
+/** Entry points that re-export `queryHref` (main + the runtime re-export). */
+const QUERY_HREF_SOURCES: ReadonlySet<string> = new Set([
+  '@barefootjs/client',
+  '@barefootjs/client/runtime',
+])
+
 /**
  * Recognise a `<binding>().<method>(<args>)` env-signal method call from a
  * `call` node's callee + args, where `<binding>` is one of the local names

package/src/adapters/jsx-adapter.ts

@@ -12,6 +12,7 @@ import type {
 } from '../types.ts'
 import { BF_SCOPE, BF_SLOT, BF_COND } from '@barefootjs/shared'
 import { BaseAdapter } from './interface.ts'
+import { ENV_SIGNAL_CLIENT_FACTORY } from './env-signal.ts'
 import { formatParamWithType, findReachableNames } from '../module-exports.ts'
 
 export interface JsxAdapterConfig {
@@ -110,6 +111,22 @@ export abstract class JsxAdapter extends BaseAdapter {
 
     for (const signal of ir.metadata.signals) {
       if (signal.isModule) continue
+      if (signal.envReader) {
+        // Env signal (#2057): call the real runtime factory so SSR resolves the
+        // request query through the installed server env reader, not a static
+        // initial value. Emit the factory as written (alias / namespace aware),
+        // matching the import re-emitted into the SSR module; fall back to the
+        // canonical name if the callee text wasn't captured.
+        const factory = signal.envFactory ?? ENV_SIGNAL_CLIENT_FACTORY[signal.envReader]
+        if (factory) {
+          lines.push(
+            signal.setter
+              ? `  const [${signal.getter}, ${signal.setter}] = ${factory}()`
+              : `  const [${signal.getter}] = ${factory}()`,
+          )
+        }
+        continue
+      }
       // Create a getter that returns the initial value for SSR
       const rawInitialValue = preserveTypes
         ? (signal.typedInitialValue ?? signal.initialValue)

package/src/adapters/parsed-expr-emitter.ts

@@ -33,7 +33,8 @@
  *     be added in one place.
  */
 
-import type { ParsedExpr, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '../expression-parser.ts'
+import type { ParsedExpr, FlatDepth, TemplatePart, ObjectLiteralProperty } from '../expression-parser.ts'
+import { asCallbackMethodCall } from '../expression-parser.ts'
 
 export type HigherOrderMethod = 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'
 
@@ -139,49 +140,48 @@ export interface ParsedExprEmitter {
     emit: (e: ParsedExpr) => string,
   ): string
   templateLiteral(parts: TemplatePart[], emit: (e: ParsedExpr) => string): string
-  arrowFn(param: string, body: ParsedExpr, emit: (e: ParsedExpr) => string): string
-  higherOrder(
-    method: HigherOrderMethod,
+  // A higher-order callback method call (`<object>.<method>(<arrow>, …rest)`,
+  // method ∈ `CALLBACK_METHODS`): `.filter`/`.find`/`.every`/`.some`/`.sort`/
+  // `.reduce`/`.flatMap`/… (#2018 P5). The adapter serializes the `arrow` body
+  // to the runtime evaluator (eval-first) and falls back to a structured
+  // lowering when the body is outside the evaluator surface. `restArgs` carries
+  // any trailing arguments (e.g. the `.reduce` init).
+  callbackMethod(
+    method: string,
     object: ParsedExpr,
-    param: string,
-    predicate: ParsedExpr,
+    arrow: Extract<ParsedExpr, { kind: 'arrow' }>,
+    restArgs: ParsedExpr[],
     emit: (e: ParsedExpr) => string,
   ): string
+  // A standalone arrow / regex literal. These normally reach an adapter only as
+  // a callback argument (handled by `callbackMethod`); emitted standalone they
+  // have no template form, so adapters route them to their `unsupported` path.
+  arrow(params: string[], body: ParsedExpr, emit: (e: ParsedExpr) => string): string
+  regex(raw: string): string
   arrayLiteral(elements: ParsedExpr[], emit: (e: ParsedExpr) => string): string
+  // Emit an object literal `{ a: 1, b: x }`. `raw` is the original
+  // expression string so an adapter that doesn't lower object values yet
+  // can delegate to `unsupported(raw, …)` and stay byte-identical.
+  objectLiteral(
+    properties: ObjectLiteralProperty[],
+    raw: string,
+    emit: (e: ParsedExpr) => string,
+  ): string
   arrayMethod(
     method: ArrayMethod,
     object: ParsedExpr,
     args: ParsedExpr[],
     emit: (e: ParsedExpr) => string,
   ): string
-  sortMethod(
-    method: SortMethod,
-    object: ParsedExpr,
-    comparator: SortComparator,
-    emit: (e: ParsedExpr) => string,
-  ): string
-  reduceMethod(
-    method: ReduceMethod,
-    object: ParsedExpr,
-    reduceOp: ReduceOp,
-    emit: (e: ParsedExpr) => string,
-  ): string
   // `.flat(depth?)` gets its own dispatcher arm (#1448 Tier C): it carries
   // a structured `FlatDepth` (the validated literal / `'infinity'`) rather
-  // than a `ParsedExpr[]` args list, same rationale as sort / reduce.
+  // than a `ParsedExpr[]` args list. Non-callback, so it is NOT routed
+  // through `callbackMethod`.
   flatMethod(
     object: ParsedExpr,
     depth: FlatDepth,
     emit: (e: ParsedExpr) => string,
   ): string
-  // `.flatMap(fn)` value-returning field projection gets its own arm
-  // (#1448 Tier C): it carries a structured `FlatMapOp` rather than a
-  // `ParsedExpr[]` args list, same rationale as sort / reduce / flat.
-  flatMapMethod(
-    object: ParsedExpr,
-    op: FlatMapOp,
-    emit: (e: ParsedExpr) => string,
-  ): string
   unsupported(raw: string, reason: string): string
 }
 
@@ -201,8 +201,13 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       return emitter.identifier(expr.name)
     case 'literal':
       return emitter.literal(expr.value, expr.literalType)
-    case 'call':
+    case 'call': {
+      // A higher-order callback call (`arr.filter(p)` / `arr.sort(cmp)` / …)
+      // routes to the dedicated `callbackMethod` arm; any other call is generic.
+      const cb = asCallbackMethodCall(expr)
+      if (cb) return emitter.callbackMethod(cb.method, cb.object, cb.arrow, cb.args, emit)
       return emitter.call(expr.callee, expr.args, emit)
+    }
     case 'member':
       return emitter.member(expr.object, expr.property, expr.computed, emit)
     case 'index-access':
@@ -217,25 +222,18 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       return emitter.conditional(expr.test, expr.consequent, expr.alternate, emit)
     case 'template-literal':
       return emitter.templateLiteral(expr.parts, emit)
-    case 'arrow-fn':
-      return emitter.arrowFn(expr.param, expr.body, emit)
-    case 'higher-order':
-      return emitter.higherOrder(expr.method, expr.object, expr.param, expr.predicate, emit)
+    case 'arrow':
+      return emitter.arrow(expr.params, expr.body, emit)
+    case 'regex':
+      return emitter.regex(expr.raw)
     case 'array-literal':
       return emitter.arrayLiteral(expr.elements, emit)
+    case 'object-literal':
+      return emitter.objectLiteral(expr.properties, expr.raw, emit)
     case 'array-method':
-      if (expr.method === 'sort' || expr.method === 'toSorted') {
-        return emitter.sortMethod(expr.method, expr.object, expr.comparator, emit)
-      }
-      if (expr.method === 'reduce' || expr.method === 'reduceRight') {
-        return emitter.reduceMethod(expr.method, expr.object, expr.reduceOp, emit)
-      }
       if (expr.method === 'flat') {
         return emitter.flatMethod(expr.object, expr.flatDepth, emit)
       }
-      if (expr.method === 'flatMap') {
-        return emitter.flatMapMethod(expr.object, expr.flatMapOp, emit)
-      }
       return emitter.arrayMethod(expr.method, expr.object, expr.args, emit)
     case 'unsupported':
       return emitter.unsupported(expr.raw, expr.reason)

package/src/analyzer-context.ts

@@ -344,11 +344,21 @@ function propertyNameText(
 
 export function typeNodeToTypeInfo(
   typeNode: ts.TypeNode | undefined,
-  sourceFile: ts.SourceFile
+  sourceFile: ts.SourceFile,
+  // When set, `raw` is derived from this extractor instead of
+  // `node.getText(sourceFile)`. Synthetic nodes (from `checker.typeToTypeNode`,
+  // used by `tsTypeToTypeInfo`) have no source positions, so `getText()` would
+  // throw — callers pass a printer-based extractor. In that mode the
+  // object-literal / function branches that need member/param source text emit
+  // a `raw`-only shape (those consumers only run on real source).
+  rawOf?: (node: ts.TypeNode) => string
 ): TypeInfo | null {
   if (!typeNode) return null
 
-  const raw = typeNode.getText(sourceFile)
+  const synthetic = rawOf !== undefined
+  const raw = rawOf ? rawOf(typeNode) : typeNode.getText(sourceFile)
+  const recurse = (n: ts.TypeNode): TypeInfo =>
+    typeNodeToTypeInfo(n, sourceFile, rawOf) ?? { kind: 'unknown', raw: 'unknown' }
 
   // Primitive types (check by SyntaxKind)
   switch (typeNode.kind) {
@@ -366,26 +376,12 @@ export function typeNodeToTypeInfo(
 
   // Array types
   if (ts.isArrayTypeNode(typeNode)) {
-    return {
-      kind: 'array',
-      raw,
-      elementType: typeNodeToTypeInfo(typeNode.elementType, sourceFile) ?? {
-        kind: 'unknown',
-        raw: 'unknown',
-      },
-    }
+    return { kind: 'array', raw, elementType: recurse(typeNode.elementType) }
   }
 
   // Union types
   if (ts.isUnionTypeNode(typeNode)) {
-    return {
-      kind: 'union',
-      raw,
-      unionTypes: typeNode.types.map(
-        (t) =>
-          typeNodeToTypeInfo(t, sourceFile) ?? { kind: 'unknown', raw: 'unknown' }
-      ),
-    }
+    return { kind: 'union', raw, unionTypes: typeNode.types.map(recurse) }
   }
 
   // Type literal (object type)
@@ -393,7 +389,9 @@ export function typeNodeToTypeInfo(
     return {
       kind: 'object',
       raw,
-      properties: membersToProperties(typeNode.members, sourceFile),
+      // Synthetic members have no source positions for membersToProperties'
+      // getText(); emit a property-less object in that mode.
+      ...(synthetic ? {} : { properties: membersToProperties(typeNode.members, sourceFile) }),
     }
   }
 
@@ -407,14 +405,7 @@ export function typeNodeToTypeInfo(
       (refName === 'Array' || refName === 'ReadonlyArray') &&
       typeNode.typeArguments?.length === 1
     ) {
-      return {
-        kind: 'array',
-        raw,
-        elementType: typeNodeToTypeInfo(typeNode.typeArguments[0], sourceFile) ?? {
-          kind: 'unknown',
-          raw: 'unknown',
-        },
-      }
+      return { kind: 'array', raw, elementType: recurse(typeNode.typeArguments[0]) }
     }
     return {
       kind: 'interface',
@@ -424,6 +415,8 @@ export function typeNodeToTypeInfo(
 
   // Function type
   if (ts.isFunctionTypeNode(typeNode)) {
+    // Param names/defaults come from getText — skip them for synthetic nodes.
+    if (synthetic) return { kind: 'function', raw }
     return {
       kind: 'function',
       raw,
@@ -443,6 +436,40 @@ export function typeNodeToTypeInfo(
   return { kind: 'unknown', raw }
 }
 
+// Printer + blank source file reused across calls so checker-driven type
+// conversion never allocates a fresh `ts.createSourceFile` per memo on the
+// build hot path (the blank file is only printer context for synthetic
+// nodes, created once at module load).
+const _typePrinter = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true })
+const _blankTypeSourceFile = ts.createSourceFile('__bf_types__.ts', '', ts.ScriptTarget.Latest)
+
+/**
+ * Convert a resolved `ts.Type` to `TypeInfo` via the type checker. Used to
+ * sharpen `createMemo` field types the syntactic `inferTypeFromValue`
+ * heuristic can't reach — e.g. `createMemo(() => generateDays())` whose body
+ * is a local-function call (→ `CalendarDay[][]`) or a ternary of typed
+ * arrays (→ `string[]`). Without this the Go adapter renders such memos as
+ * `map[string]interface{}` / `bool` placeholders, so a typed backend can't
+ * populate the SSR data (#1968). Returns `null` when the type can't be
+ * lowered to a `ts.TypeNode`.
+ *
+ * Shares the structural lowering in `typeNodeToTypeInfo` (via the `rawOf`
+ * extractor) so node→TypeInfo logic lives in one place; the synthetic nodes
+ * from `typeToTypeNode` have no source text, so `raw` comes from the printer.
+ */
+export function tsTypeToTypeInfo(type: ts.Type, checker: ts.TypeChecker): TypeInfo | null {
+  const node = checker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation)
+  if (!node) return null
+  const rawOf = (n: ts.TypeNode): string => {
+    try {
+      return _typePrinter.printNode(ts.EmitHint.Unspecified, n, _blankTypeSourceFile)
+    } catch {
+      return 'unknown'
+    }
+  }
+  return typeNodeToTypeInfo(node, _blankTypeSourceFile, rawOf)
+}
+
 // =============================================================================
 // AST Helpers
 // =============================================================================
@@ -474,3 +501,21 @@ export function isArrowComponentFunction(
   if (!node.initializer || !ts.isArrowFunction(node.initializer)) return false
   return true
 }
+
+/**
+ * The set of reactive getter names for a component — signal accessors plus memo
+ * names. Single source of truth for "what counts as a reactive getter", shared
+ * by the analyzer's block-memo fold purity oracle (#2040) and `jsx-to-ir`'s
+ * `getReactiveGetterNames`. A reactive read is idempotent within a render, so
+ * callers treat `getter()` as pure. If a third reactive kind is added, update
+ * this one function.
+ */
+export function collectReactiveGetterNames(
+  signals: ReadonlyArray<{ getter: string }>,
+  memos: ReadonlyArray<{ name: string }>,
+): Set<string> {
+  const names = new Set<string>()
+  for (const s of signals) names.add(s.getter)
+  for (const m of memos) names.add(m.name)
+  return names
+}