@barefootjs/go-template 0.17.0 → 0.17.1

package/src/adapter/memo/memo-compute.ts

@@ -9,10 +9,17 @@
  */
 
 import type { ParsedExpr, ParsedStatement, TypeInfo } from '@barefootjs/jsx'
+import {
+  asCallbackMethodCall,
+  freeVarsInBody,
+  materializeGetterCalls,
+  serializeParsedExpr,
+} from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import type { PropFallbackVar } from '../lib/types.ts'
 import { capitalizeFieldName } from '../lib/go-naming.ts'
+import { escapeGoString } from '../lib/go-emit.ts'
 import { convertInitialValue, getSignalInitialValueAsGo } from '../value/value-lowering.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 import { computeTemplateLiteralMemoInitialValue } from './template-interp.ts'
@@ -21,6 +28,91 @@ import { resolveBlockBodyMemoModuleConst, computeObjectMemoInitialValue } from '
 /** Default for the optional `propFallbackVars` argument. */
 const EMPTY_PROP_FALLBACK_VARS: ReadonlyMap<string, PropFallbackVar> = new Map()
 
+/** A bare zero-arg getter call (`count()`) → its name, else null. */
+function getterCallName(e: ParsedExpr): string | null {
+  return e.kind === 'call' && e.callee.kind === 'identifier' && e.args.length === 0
+    ? e.callee.name
+    : null
+}
+
+/** A `props.X` member access → the prop name, else null. */
+function propsMemberName(e: ParsedExpr): string | null {
+  return e.kind === 'member' &&
+    !e.computed &&
+    e.object.kind === 'identifier' &&
+    e.object.name === 'props'
+    ? e.property
+    : null
+}
+
+/** A `() => props.X.filter((p) => <predicate>)` match: the array prop name,
+ *  the predicate serialized to the runtime evaluator's ParsedExpr JSON, the
+ *  arrow's param name, and the free variable names its predicate captures.
+ *  Null when `body` isn't this shape, `propName` doesn't resolve to a known
+ *  prop, or the predicate isn't representable (`serializeParsedExpr` refusal).
+ *  Shared by the SSR-value emitter ({@link memoInitialFromParsedBody}) and the
+ *  constructor's sibling-memo hoisting pre-pass so both walk the shape
+ *  identically. */
+export function matchFilterArmMemo(
+  ctx: GoEmitContext,
+  body: ParsedExpr,
+  signals: { getter: string; initialValue: string }[],
+  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+): { propName: string; predJSON: string; paramName: string; freeVars: string[] } | null {
+  const cb = asCallbackMethodCall(body)
+  if (!cb || cb.method !== 'filter') return null
+  const propName = propsMemberName(cb.object)
+  const param = propName ? propsParams.find(p => p.name === propName) : undefined
+  if (!propName || !param) return null
+
+  // Single authority (Package G plan): every step that isn't `env-reader` is
+  // value-materializable at SSR time — env readers are per-request readers
+  // the runtime evaluator can't invoke, so they're excluded here exactly as
+  // the plan's own consumers exclude them.
+  const knownGetterNames = new Set<string>(
+    ctx.state.ssrSeedPlan.steps.filter(s => s.kind !== 'env-reader').map(s => s.name),
+  )
+
+  const materialized = materializeGetterCalls(cb.arrow.body, knownGetterNames)
+  const predJSON = serializeParsedExpr(materialized)
+  if (predJSON === null) return null
+
+  const paramName = cb.arrow.params[0] ?? '_'
+  const freeVars = freeVarsInBody(materialized, new Set(cb.arrow.params))
+  return { propName, predJSON, paramName, freeVars }
+}
+
+/**
+ * Names of EARLIER sibling memos (per `ctx.state.currentMemos` declaration
+ * order) that a filter-arm memo's predicate free variables resolve to — the
+ * constructor generator hoists these into a shared local so the sibling's
+ * expression isn't emitted twice (once for its own field, once inlined in
+ * this memo's `bf.FilterEval` env map, #2075/#2077 review finding 3). Empty
+ * when `memo` isn't a filter-arm memo or references nothing hoistable.
+ */
+export function filterArmEarlierSiblingRefs(
+  ctx: GoEmitContext,
+  memo: { name: string; parsed?: ParsedExpr },
+  signals: { getter: string; initialValue: string }[],
+  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+): string[] {
+  if (!memo.parsed) return []
+  const match = matchFilterArmMemo(ctx, memo.parsed, signals, propsParams)
+  if (!match) return []
+  // `currentMemos` order equals the plan's memo-step order (plan lists
+  // signals first, then memos, both in declaration order) — kept here rather
+  // than filtering `ssrSeedPlan.steps` since this index is memo-only already.
+  const memos = ctx.state.currentMemos ?? []
+  const currentIndex = memos.findIndex(m => m.name === memo.name)
+  if (currentIndex < 0) return []
+  const refs: string[] = []
+  for (const name of match.freeVars) {
+    const idx = memos.findIndex(m => m.name === name)
+    if (idx >= 0 && idx < currentIndex) refs.push(name)
+  }
+  return refs
+}
+
 /**
  * Compute a memo's SSR initial value as a Go expression — e.g.
  * `() => count() * 2` → `in.Initial * 2`, `() => props.value * 10` →
@@ -39,8 +131,11 @@ export function computeMemoInitialValue(
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
   goType?: string,
 ): string {
+  // Seed the resolution stack with this memo's own name — every external call
+  // is a fresh top-level computation, so self-reference must be caught on the
+  // very first recursion, not only on the second visit.
   const resolved = computeMemoInitialValueOrNull(
-    ctx, memo, signals, propsParams, propFallbackVars,
+    ctx, memo, signals, propsParams, propFallbackVars, new Set([memo.name]),
   )
   if (resolved !== null) return resolved
   // Zero value for the memo's Go type: `false` for bool, `""` for string,
@@ -76,25 +171,112 @@ export function memoInitialFromParsedBody(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  currentMemoName: string,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   const propRef = (propName: string): string => {
     const hoisted = propFallbackVars.get(propName)
     if (hoisted) return hoisted.varName
     return `in.${capitalizeFieldName(propName)}`
   }
-  // A bare zero-arg getter call (`count()`) → its name, else null.
-  const getterCallName = (e: ParsedExpr): string | null =>
-    e.kind === 'call' && e.callee.kind === 'identifier' && e.args.length === 0
-      ? e.callee.name
-      : null
-  // A `props.X` member access → the prop name, else null.
-  const propsMemberName = (e: ParsedExpr): string | null =>
-    e.kind === 'member' &&
-    !e.computed &&
-    e.object.kind === 'identifier' &&
-    e.object.name === 'props'
-      ? e.property
-      : null
+  // A request-scoped env-signal read (`searchParams().get('k')`, any local
+  // alias, #1922) → the literal key and the reader's canonical field name,
+  // else null. Constraints: the receiver must be a zero-arg call of a local
+  // bound to a registered env signal (`ctx.state.envSignalReadersByLocal`,
+  // keyed by that reader's own registration — not a hardcoded key); the
+  // method must be one that reader's `methods` set recognises; the key
+  // argument must be a string literal.
+  const envGetKey = (e: ParsedExpr): { key: string; fieldName: string } | null => {
+    if (e.kind !== 'call' || e.callee.kind !== 'member' || e.callee.computed) return null
+    const recvName = getterCallName(e.callee.object)
+    if (recvName === null) return null
+    const reader = ctx.state.envSignalReadersByLocal.get(recvName)
+    if (!reader || !reader.methods.has(e.callee.property)) return null
+    const arg = e.args[0]
+    if (!arg || arg.kind !== 'literal' || arg.literalType !== 'string') return null
+    return { key: String(arg.value), fieldName: capitalizeFieldName(reader.canonicalName) }
+  }
+
+  // () => searchParams().get('k') — a derived memo over the env signal
+  // (#2069). The constructor reads the canonical `in.SearchParams` reader the
+  // handler fills per request, so the memo SSR-computes instead of zero-valuing.
+  {
+    const m = envGetKey(body)
+    if (m !== null) return `in.${m.fieldName}.Get(${JSON.stringify(m.key)})`
+  }
+
+  // () => searchParams().get('k') ?? '<lit>' — the defaulted form. Go's
+  // `SearchParams.Get` returns "" for an absent key (it can't surface JS's
+  // null), so the default fires on "" — the same documented `?? → or`
+  // divergence as the template-position lowering (`or (.SearchParams.Get
+  // "k") "<lit>"`); the two positions stay consistent.
+  if (
+    body.kind === 'logical' &&
+    (body.op === '??' || body.op === '||') &&
+    body.right.kind === 'literal' &&
+    body.right.literalType === 'string'
+  ) {
+    const m = envGetKey(body.left)
+    if (m !== null) {
+      const def = JSON.stringify(String(body.right.value))
+      return `func() string { if v := in.${m.fieldName}.Get(${JSON.stringify(m.key)}); v != "" { return v }; return ${def} }()`
+    }
+  }
+
+  // () => props.X.filter((p) => <predicate>) — a LIST-valued derived memo
+  // chained off a sibling memo the predicate closes over (e.g. a
+  // searchParams()-derived `tag`). Env-signal getters are excluded from the
+  // free-var materialization set: they're per-request READERS, not values,
+  // and the runtime evaluator has no way to invoke one.
+  {
+    const match = matchFilterArmMemo(ctx, body, signals, propsParams)
+    if (match) {
+      const { propName, predJSON, paramName, freeVars } = match
+      const currentIndex = (ctx.state.currentMemos ?? []).findIndex(m => m.name === currentMemoName)
+      const envEntries: string[] = []
+      let unresolved = false
+      for (const name of freeVars) {
+        let goExpr: string | null = null
+        const siblingIndex = (ctx.state.currentMemos ?? []).findIndex(m => m.name === name)
+        if (siblingIndex >= 0) {
+          // Only a sibling declared EARLIER than the memo being computed is
+          // eligible — mirrors JS declaration order and rules out both
+          // self-reference and any mutual pair (at most one direction can
+          // satisfy `earlier`), independent of the resolving-stack guard
+          // below. A hoisted local (the constructor emitted it once already,
+          // #2075/#2077 review finding 3) is reused verbatim instead of
+          // recomputing the expression a second time.
+          const siblingMemo = ctx.state.currentMemos![siblingIndex]
+          const eligible = currentIndex >= 0 && siblingIndex < currentIndex && !resolving.has(siblingMemo.name)
+          if (eligible) {
+            const hoisted = ctx.state.hoistedMemoLocals.get(siblingMemo.name)
+            goExpr = hoisted ?? computeMemoInitialValueOrNull(
+              ctx, siblingMemo, signals, propsParams, propFallbackVars,
+              new Set([...resolving, siblingMemo.name]),
+            )
+          }
+        } else {
+          const sig = signals.find(s => s.getter === name)
+          if (sig) {
+            goExpr = getSignalInitialValueAsGo(ctx, sig.initialValue, propsParams, propFallbackVars)
+          } else {
+            const p = propsParams.find(pp => pp.name === name)
+            if (p) goExpr = propRef(name)
+          }
+        }
+        if (goExpr === null) {
+          unresolved = true
+          break
+        }
+        envEntries.push(`${JSON.stringify(name)}: ${goExpr}`)
+      }
+      if (!unresolved) {
+        const itemsField = `in.${capitalizeFieldName(propName)}`
+        const envMap = `map[string]any{${envEntries.join(', ')}}`
+        return `bf.FilterEval(${itemsField}, "${escapeGoString(predJSON)}", ${JSON.stringify(paramName)}, ${envMap})`
+      }
+    }
+  }
 
   // () => getter() === 'lit' / !== 'lit' — a selection memo. Resolves to a Go
   // bool when the signal's initial value is itself a string literal.
@@ -150,8 +332,15 @@ export function memoInitialFromParsedBody(
           condGo = getSignalInitialValueAsGo(ctx, condSignal.initialValue, propsParams, propFallbackVars)
         } else {
           const condMemo = (ctx.state.currentMemos ?? []).find(m => m.name === condName)
-          if (condMemo) {
-            condGo = computeMemoInitialValueOrNull(ctx, condMemo, signals, propsParams, propFallbackVars)
+          // A condition memo already on the resolution stack (self- or
+          // mutually-referencing ternaries) falls back to null — the same
+          // zero-value default as any other unresolved shape — instead of
+          // recursing forever.
+          if (condMemo && !resolving.has(condMemo.name)) {
+            condGo = computeMemoInitialValueOrNull(
+              ctx, condMemo, signals, propsParams, propFallbackVars,
+              new Set([...resolving, condMemo.name]),
+            )
           }
         }
         if (condGo === 'true') return t
@@ -259,6 +448,15 @@ export function computeMemoInitialValueOrNull(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
+  /**
+   * Memo names currently being resolved on this call stack — guards against
+   * unbounded recursion when memos reference each other (mutually, or a
+   * self-reference). Callers that start a fresh top-level computation seed
+   * this with `memo.name`; recursive calls extend it with the sibling memo
+   * about to be entered. A candidate already in the set resolves to `null`
+   * (the shape's usual "unsupported" fallback) instead of recursing.
+   */
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   const computation = memo.computation
 
@@ -275,6 +473,8 @@ export function computeMemoInitialValueOrNull(
       signals,
       propsParams,
       propFallbackVars,
+      memo.name,
+      resolving,
     )
     if (fromParsed !== null) return fromParsed
   }
@@ -288,6 +488,7 @@ export function computeMemoInitialValueOrNull(
     signals,
     propsParams,
     propFallbackVars,
+    resolving,
   )
   if (cmpTernary !== null) return cmpTernary
 
@@ -329,6 +530,7 @@ export function resolveGetterValueAsGo(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   const signal = signals.find(s => s.getter === name)
   if (signal) {
@@ -336,13 +538,18 @@ export function resolveGetterValueAsGo(
   }
   const memo = (ctx.state.currentMemos ?? []).find(m => m.name === name)
   if (memo) {
+    // Already on the resolution stack (self- or mutually-referencing
+    // ternary operands) — fall back to null rather than recurse forever.
+    if (resolving.has(memo.name)) return null
     const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, '')
     const fb = ctx.extractPropFallback(stripped)
     if (fb && capitalizeFieldName(fb.propName) === capitalizeFieldName(memo.name)) {
       const field = `in.${capitalizeFieldName(fb.propName)}`
       return `func() interface{} { v := interface{}(${field}); if v == nil || v == "" { return ${fb.goFallback} }; return v }()`
     }
-    return computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars)
+    return computeMemoInitialValueOrNull(
+      ctx, memo, signals, propsParams, propFallbackVars, new Set([...resolving, memo.name]),
+    )
   }
   const param = propsParams.find(p => p.name === name)
   if (param) {
@@ -366,6 +573,7 @@ export function computeComparisonTernaryGo(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   // Matches any `conditional` `parsed` — an expression-bodied ternary or, since
   // #2040, a block-bodied memo whose value `if` / early-return folded to one.
@@ -398,6 +606,7 @@ export function computeComparisonTernaryGo(
     signals,
     propsParams,
     propFallbackVars,
+    resolving,
   )
   if (condGo === null) return null
 
@@ -420,10 +629,11 @@ export function resolveComparisonOperandGo(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   // getter(): a signal or memo getter call.
   if (node.kind === 'call' && node.callee.kind === 'identifier' && node.args.length === 0) {
-    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars)
+    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars, resolving)
   }
   // props.X ?? 'def' — nil/empty-tolerant field read with the default folded in.
   if (node.kind === 'logical' && node.op === '??' && node.right.kind === 'literal' && node.right.literalType === 'string') {

package/src/adapter/memo/memo-type.ts

@@ -6,11 +6,25 @@
  * right SSR zero value).
  */
 
+import { asCallbackMethodCall } from '@barefootjs/jsx'
 import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 
+/**
+ * True when a memo's body is a `.filter(<arrow>)` callback-method call
+ * (#2075) — a LIST-valued derived memo (the blog PostList `visible` shape:
+ * `createMemo(() => props.items.filter((p) => …))`), not a scalar. Exported
+ * so both `isBooleanMemo` (guard below) and `inferMemoType`'s field-type
+ * decision (go-template-adapter.ts) share the one recognition point.
+ */
+export function isListFilterMemo(memo: { parsed?: ParsedExpr }): boolean {
+  if (!memo.parsed) return false
+  const cb = asCallbackMethodCall(memo.parsed)
+  return cb !== null && cb.method === 'filter'
+}
+
 /**
  * Heuristic: does this memo evaluate to a boolean? True when its computation is
  * a comparison (`!==`/`===`/`!=`/`==`), a negation (`!x`), or a ternary whose
@@ -24,6 +38,11 @@ export function isBooleanMemo(
   propsParamMap: Map<string, { name: string; type: TypeInfo; defaultValue?: string }>,
 ): boolean {
   const c = memo.computation
+  // A LIST-valued `.filter(arrow)` memo (#2075) is never boolean, even though
+  // its predicate arrow body often contains a `!` negation (`!tag() || …`) —
+  // that would otherwise trip the `/=>\s*!/` heuristic below into
+  // misclassifying the whole memo. Bail before any regex runs.
+  if (isListFilterMemo(memo)) return false
   // A ternary whose two branches are string literals is a STRING memo, not
   // boolean — the `===` lives in the *condition*, so the blanket comparison
   // check below would misclassify it as bool and bake `false`. Bail first.

package/src/test-render.ts

@@ -615,13 +615,23 @@ function buildGoPropsInit(
       // a bare `[]any{…}` would fail to compile against the typed field.
       // Fall back to `[]any` when the field type is `[]any` / unknown.
       const elemType = goSliceElemType(goTypes, componentName, goField)
-      lines.push(
-        `\t\t${goField}: ${
-          elemType
-            ? goTypedSliceLiteralFromArray(value, elemType)
-            : goArrayLiteralFromArray(value)
-        },`,
-      )
+      let sliceLiteral: string
+      if (elemType && elemType.startsWith('map[')) {
+        // An untyped object-array Input field (an inline prop object type
+        // that didn't synthesize a named struct, e.g. `items: { title:
+        // string; tags: string[] }[]` — `typeInfoToGo`'s 'object' case,
+        // type-codegen.ts) resolves to `[]map[string]interface{}`, not a
+        // named struct. `goTypedSliceLiteralFromArray`'s `goStructLiteral`
+        // emits bare `Field: value` entries, which is struct-literal syntax
+        // and doesn't compile as a map literal's keys — route these through
+        // the map-literal builder instead (#2075, search-params-derived-filter).
+        sliceLiteral = goTypedMapSliceLiteralFromArray(value, elemType)
+      } else if (elemType) {
+        sliceLiteral = goTypedSliceLiteralFromArray(value, elemType)
+      } else {
+        sliceLiteral = goArrayLiteralFromArray(value)
+      }
+      lines.push(`\t\t${goField}: ${sliceLiteral},`)
     } else if (value && typeof value === 'object') {
       // Plain object → Go `map[string]any` literal (#1407 follow-up).
       // Used by `jsx-spread-rest-prop` to populate the input-bag
@@ -658,7 +668,11 @@ function goSliceElemType(
     new RegExp(`type ${componentName}Input struct \\{([\\s\\S]*?)\\n\\}`),
   )
   if (!struct) return null
-  const field = struct[1].match(new RegExp(`\\n\\s*${goField}\\s+\\[\\]([\\w.]+)`))
+  // The element-type token can carry brackets/braces of its own (a map type
+  // like `map[string]interface{}`), not just word chars — broadened so the
+  // capture doesn't truncate at the first `[`. The token has no internal
+  // whitespace, so it still stops cleanly before a trailing `// comment`.
+  const field = struct[1].match(new RegExp(`\\n\\s*${goField}\\s+\\[\\]([\\w.[\\]{}]+)`))
   if (!field) return null
   const elem = field[1]
   if (elem === 'any' || elem === 'interface{}') return null
@@ -683,6 +697,30 @@ function goTypedSliceLiteralFromArray(arr: unknown[], elemType: string): string
   return `[]${elemType}{${entries.join(', ')}}`
 }
 
+/**
+ * Emit a typed Go slice-of-map literal (`[]map[string]interface{}{map[string]any{…}, …}`)
+ * for an untyped object-array Input field. Object elements become
+ * `map[string]any{"Field": val, …}` literals with PascalCase keys — Go
+ * template map lookup is case-sensitive, so `{{.Title}}` needs a capitalized
+ * key, same as the untyped `goArrayLiteralFromArray` fallback's object
+ * entries. `map[string]any` and `map[string]interface{}` are the identical
+ * type (`any` is the builtin alias for `interface{}`), so the emitted
+ * literal is assignable to `elemType` regardless of which spelling the
+ * Input struct field carries. (#2075, search-params-derived-filter)
+ */
+function goTypedMapSliceLiteralFromArray(arr: unknown[], elemType: string): string {
+  const entries = arr.map(v => {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      return goMapLiteralFromObject(v as Record<string, unknown>, true)
+    }
+    if (typeof v === 'string') return `"${v.replace(/"/g, '\\"')}"`
+    if (typeof v === 'number' || typeof v === 'boolean') return String(v)
+    if (v === null) return 'nil'
+    return goArrayLiteralFromArray(v as unknown[])
+  })
+  return `[]${elemType}{${entries.join(', ')}}`
+}
+
 /**
  * Emit a keyed Go struct literal (`Elem{Field: val, …}`) with PascalCase field
  * names. Only the keys the caller supplied are set, so an omitted optional prop