@barefootjs/go-template 0.33.4 → 0.34.0

package/src/adapter/expr/url-builder.ts

@@ -128,6 +128,44 @@ function lowerTernaryTest(ctx: GoEmitContext, test: ParsedExpr): string {
   return isBoolShape ? go : `(bf_truthy ${go})`
 }
 
+/**
+ * First registered matcher that recognises `callee(args)`, or null (#2842).
+ * The single registry consultation every Go lowering path shares: the
+ * top-level `lowerRegisteredCall` early return, the ParsedExpr `call()`
+ * dispatcher (`go-template-adapter.ts`, so a registered call is recognised no
+ * matter how deep it sits in an expression tree — a ternary branch, a
+ * template-literal interpolation, a binary operand — not only when the call
+ * IS the whole expression), and the attribute-position `bf_attr` route all
+ * ask this one question. First-match-wins: a malformed helper id from one
+ * plugin must not be silently masked by falling through to another.
+ */
+export function matchRegisteredCall(
+  ctx: GoEmitContext,
+  callee: ParsedExpr,
+  args: readonly ParsedExpr[],
+): LoweringNode | null {
+  for (const matcher of ctx.state.loweringMatchers) {
+    const node = matcher(callee, args)
+    if (node) return node
+  }
+  return null
+}
+
+/**
+ * Render a recognised call's neutral node to its Go pipeline (unparenthesised
+ * — same contract as `lowerRegisteredCall`), or null when no plugin matches
+ * or the matched helper has no Go mapping.
+ */
+export function lowerRegisteredCallNode(
+  ctx: GoEmitContext,
+  callee: ParsedExpr,
+  args: readonly ParsedExpr[],
+): string | null {
+  if (ctx.state.loweringMatchers.length === 0) return null
+  const node = matchRegisteredCall(ctx, callee, args)
+  return node ? renderLoweringNode(ctx, node) : null
+}
+
 /**
  * Lower a helper call to a Go template expression, or null when no registered
  * plugin recognises it (→ the generic lowering). Matchers — including the
@@ -144,8 +182,7 @@ export function lowerRegisteredCall(
   jsExpr: string,
   preParsed?: ParsedExpr,
 ): string | null {
-  const matchers = ctx.state.loweringMatchers
-  if (matchers.length === 0) return null
+  if (ctx.state.loweringMatchers.length === 0) return null
 
   let call: ParsedExpr | undefined = preParsed?.kind === 'call' ? preParsed : undefined
   if (!call) {
@@ -155,13 +192,82 @@ export function lowerRegisteredCall(
     call = parsed
   }
 
-  for (const matcher of matchers) {
-    const node = matcher(call.callee, call.args)
-    if (!node) continue
-    const rendered = renderLoweringNode(ctx, node)
-    if (rendered !== null) return rendered
+  return lowerRegisteredCallNode(ctx, call.callee, call.args)
+}
+
+/**
+ * Attribute-position twin of `lowerRegisteredCall` (#2743). When an intrinsic
+ * element attribute's value is a `query` guard-list (the neutral node the
+ * `queryHref` plugin — or any plugin reusing the `query` helper — produces),
+ * emit the WHOLE attribute as one `bf_attr` action returning
+ * `template.HTMLAttr`, instead of `name="{{bf_query …}}"`. html/template
+ * infers a URL context from the attribute NAME (`href`, `src`, `action`,
+ * `data-*`, anything containing `src`/`uri`/`url`, …) and percent-encodes the
+ * entire value there; the JS reference (Hono) only HTML-escapes. Keyed on the
+ * neutral `helper` id, not the attribute name (Go's URL-context table is a
+ * heuristic we must not re-implement) and not the JS API name. Returns null
+ * for a non-call, an unmatched call, or any other node kind/helper — the
+ * caller then takes its ordinary path.
+ *
+ * Also accepts a `conditional` node directly (#2743 follow-up, pullfrog
+ * review on #2841): a ternary with a real, non-`undefined` alternate
+ * (`cond ? queryHref(...) : '/fallback'`) is syntactically valid and already
+ * lowers its branches correctly via `lowerTernary` — but the CALLER used to
+ * still wrap the resulting `(bf_ternary …)` pipeline in the ordinary
+ * `name="{{...}}"` form, which leaves it exposed to the same URL-context
+ * percent-encoding this function exists to route around. Whenever EITHER
+ * branch (recursing through a right-folded nested ternary chain, the same
+ * shape `lowerTernary` itself right-folds) is a `query` guard-list call, the
+ * whole ternary is wrapped in `bf_attr` too — matching the reference, which
+ * HTML-escapes the picked branch's value the same way regardless of which
+ * branch won.
+ *
+ * The caller passes the CONSEQUENT ALONE (not the full ternary) for the
+ * `undefined`-alternate omission shape (`cond ? queryHref(...) : undefined`,
+ * #2842) — omission needs the `{{if}}` wrapper that shape's caller already
+ * builds; a `bf_ternary … ""` inside `bf_attr` can't express it (`Attr`
+ * renders `name=""` for an empty value, not attribute absence).
+ */
+export function lowerRegisteredAttrCall(
+  ctx: GoEmitContext,
+  attrName: string,
+  parsed: ParsedExpr,
+): string | null {
+  if (parsed.kind === 'conditional') {
+    if (!ternaryHasQueryBranch(ctx, parsed.consequent, parsed.alternate)) return null
+    // `lowerTernary` already returns a complete parenthesised `(bf_ternary …)`
+    // pipeline — pass it straight through as `bf_attr`'s value argument
+    // rather than re-wrapping it in a redundant second set of parens.
+    const rendered = lowerTernary(ctx, parsed.test, parsed.consequent, parsed.alternate)
+    return `{{bf_attr ${JSON.stringify(attrName)} ${rendered}}}`
   }
-  return null
+  if (parsed.kind !== 'call') return null
+  const node = matchRegisteredCall(ctx, parsed.callee, parsed.args)
+  if (!node || node.kind !== 'guard-list' || node.helper !== 'query') return null
+  const rendered = renderLoweringNode(ctx, node)
+  return rendered === null ? null : `{{bf_attr ${JSON.stringify(attrName)} (${rendered})}}`
+}
+
+/** Whether a `call` node is a recognised `query` guard-list lowering. */
+function isQueryGuardListCall(ctx: GoEmitContext, node: ParsedExpr): boolean {
+  if (node.kind !== 'call') return false
+  const lowered = matchRegisteredCall(ctx, node.callee, node.args)
+  return lowered?.kind === 'guard-list' && lowered.helper === 'query'
+}
+
+/**
+ * Whether either branch of a ternary is (or, for a right-folded chain,
+ * eventually resolves to) a `query` guard-list call — the trigger for
+ * routing the whole ternary through `bf_attr` in `lowerRegisteredAttrCall`.
+ */
+function ternaryHasQueryBranch(
+  ctx: GoEmitContext,
+  consequent: ParsedExpr,
+  alternate: ParsedExpr,
+): boolean {
+  const branchHasQuery = (n: ParsedExpr): boolean =>
+    n.kind === 'conditional' ? ternaryHasQueryBranch(ctx, n.consequent, n.alternate) : isQueryGuardListCall(ctx, n)
+  return branchHasQuery(consequent) || branchHasQuery(alternate)
 }
 
 /**