@barefootjs/go-template 0.1.0

package/dist/adapter/go-template-adapter.d.ts

@@ -0,0 +1,683 @@
+/**
+ * BarefootJS Go html/template Adapter
+ *
+ * Generates Go html/template files from BarefootJS IR.
+ */
+import type { ComponentIR, IRNode, IRElement, IRText, IRExpression, IRConditional, IRLoop, IRComponent, IRFragment, IRSlot, ParsedExpr, SortComparator, TemplatePart, IRIfStatement, IRProvider, IRAsync, TemplatePrimitiveRegistry } from '@barefootjs/jsx';
+import { BaseAdapter, type AdapterOutput, type AdapterGenerateOptions, type ParsedExprEmitter, type HigherOrderMethod, type ArrayMethod, type LiteralType, type IRNodeEmitter, type EmitIRNode } from '@barefootjs/jsx';
+/**
+ * Go-template adapter's IRNode render context. Only `isRootOfClientComponent`
+ * is consumed today (forwarded into `renderComponent` / `renderIfStatement`);
+ * the type stays open so future render-position flags can be added without
+ * widening the `IRNodeEmitter` contract.
+ */
+type GoRenderCtx = {
+    isRootOfClientComponent?: boolean;
+};
+export interface GoTemplateAdapterOptions {
+    /** Go package name for generated types (default: 'components') */
+    packageName?: string;
+    /**
+     * Base path for client JS files (e.g., '/static/client/').
+     * Used to generate script registration paths.
+     */
+    clientJsBasePath?: string;
+    /**
+     * Path to barefoot.js runtime (e.g., '/static/client/barefoot.js').
+     */
+    barefootJsPath?: string;
+}
+export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter, IRNodeEmitter<GoRenderCtx> {
+    name: string;
+    extension: string;
+    private filterExprDepth;
+    private filterExprUnsupported;
+    /**
+     * Identifier-path callees the Go runtime can render in template
+     * scope (#1188). The relocate pass consults this map to mark
+     * matching calls as template-safe so the surrounding expression
+     * stays inlinable; the SSR template emitter (`renderParsedExpr`'s
+     * `call` branch) uses the same map to substitute the JS call with
+     * the registered Go template form.
+     *
+     * Keys are the textual callee path as written in the JSX
+     * expression. Values are emit functions that receive the already-
+     * Go-rendered argument expressions (e.g. `.Config`, `_p.Score`)
+     * and return the substituted Go template body — without the
+     * surrounding `{{ }}` action delimiters, so callers can wrap the
+     * result in `{{...}}` or compose into larger expressions like
+     * `{{if eq (bf_json .X) "..."}}`.
+     *
+     * V1 scope (#1187 R1): identifier-path callees only. Method calls
+     * on values (`(arr).join(",")`) require analyzer-resolved receiver
+     * type and are explicitly out of scope — users fall back to
+     * `/* @client *\/` for those.
+     *
+     * Public because the `TemplateAdapter` interface contract requires
+     * the relocate pass to read this for boolean acceptance. The arity
+     * map below is implementation detail (private) — the asymmetry is
+     * deliberate.
+     */
+    templatePrimitives: TemplatePrimitiveRegistry;
+    /**
+     * Expected arg count per primitive. Consulted before invoking the
+     * registered emit fn so a 0-arg `JSON.stringify()` or 2-arg
+     * `JSON.stringify(x, replacer)` doesn't silently produce invalid
+     * Go template syntax (the V1 emit fns blindly read `args[0]`).
+     *
+     * Derived from `GO_TEMPLATE_PRIMITIVES` so it can't drift from
+     * `templatePrimitives` — a wrong-arity call falls back to the
+     * standard BF101 unsupported-call diagnostic.
+     */
+    private readonly templatePrimitiveArities;
+    private componentName;
+    private options;
+    private inLoop;
+    private loopParamStack;
+    private errors;
+    private propsObjectName;
+    /**
+     * Component-scoped rest binding identifier (`function({ a, ...rest }: P)`
+     * → `'rest'`). Stashed at `generate()` entry so per-attribute
+     * emitter callbacks can classify a spread expression against it
+     * without threading the IR through each recursion (#1407
+     * follow-up).
+     */
+    private restPropsName;
+    /** Local type names resolved from typeDefinitions (populated during generateTypes) */
+    private localTypeNames;
+    /** Local type aliases mapping type name to base type (e.g., Filter → 'string') */
+    private localTypeAliases;
+    /** Set during type generation when any emit references
+     *  `template.HTML(...)`; toggles the `"html/template"` import. */
+    private usesHtmlTemplate;
+    constructor(options?: GoTemplateAdapterOptions);
+    /**
+     * Generate template output for a component.
+     * @param ir - The component IR
+     * @param options - Generation options
+     */
+    generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput;
+    /**
+     * Check if a component has client interactivity (needs client JS).
+     * A component has client interactivity if it has:
+     * - Signals (reactive state)
+     * - Effects (side effects)
+     * - Events on elements
+     */
+    private hasClientInteractivity;
+    /**
+     * Recursively check if any element in the tree has events.
+     */
+    private hasEventsInTree;
+    /**
+     * Find all child component names used in the IR tree.
+     */
+    private findChildComponentNames;
+    private collectChildComponentNames;
+    /**
+     * Push a `BF103` diagnostic for every component reference inside a
+     * loop body whose name is imported from a relative-path module
+     * (i.e. a sibling .tsx file). The Go adapter renders these as
+     * `{{template "X" .}}` calls, which Go's template engine resolves
+     * only against templates registered on the same `*template.Template`
+     * — so a user who factored a list item into `./list-item.tsx` and
+     * mapped over it gets a working build and a `template: "X" is
+     * undefined` at request time. Surfacing this at build time matches
+     * the louder-over-silent contract (#1266).
+     *
+     * Scoped to loop bodies because that's the natural Hono-style
+     * pattern the issue calls out; static (non-loop) usage of imported
+     * components is left alone so existing static-layout patterns
+     * keep working without noise.
+     */
+    private checkImportedLoopChildComponents;
+    /**
+     * Generate script registration code for the template.
+     * Scripts are registered at the beginning of the template.
+     * Uses .Scripts which is available on all Props structs.
+     * The same ScriptCollector should be shared across parent and child props.
+     * Wrapped in {{if .Scripts}} to safely handle nil Scripts.
+     */
+    private generateScriptRegistrations;
+    generateTypes(ir: ComponentIR): string | null;
+    /**
+     * Convert a TypeScript type definition to a Go type.
+     * Handles object types → Go structs, and union string literals → string alias.
+     */
+    private typeDefinitionToGo;
+    /**
+     * Convert a raw TypeScript type string to a Go type string.
+     * Handles primitives (number, string, boolean) and basic arrays.
+     */
+    private tsTypeStringToGo;
+    /**
+     * Build a map from prop name to a better Go type inferred from signals.
+     * When a signal is initialized from a prop (e.g., createSignal(props.initial ?? 0)),
+     * the signal's type annotation may be more specific than the prop's TypeInfo.
+     */
+    private buildPropTypeOverrides;
+    /**
+     * Generate Input struct for a component
+     */
+    private generateInputStruct;
+    /**
+     * Generate Props struct for a component
+     */
+    private generatePropsStruct;
+    /**
+     * Generate NewXxxProps function
+     */
+    private generateNewPropsFunction;
+    /**
+     * Convert field name to JSON tag (camelCase)
+     */
+    private toJsonTag;
+    /**
+     * Find all nested components (loops with childComponent).
+     * Returns extended info that includes whether the component comes from a dynamic (signal) array loop.
+     */
+    private findNestedComponents;
+    private collectNestedComponents;
+    /**
+     * Collect all static child component instances from the IR tree.
+     * Excludes components inside loops (which are handled by nestedComponents).
+     *
+     * Each instance is identified by:
+     * - name: Component name (e.g., "ReactiveChild")
+     * - slotId: Unique slot ID (e.g., "slot_6")
+     * - props: Component props
+     * - fieldName: Go field name (e.g., "ReactiveChildSlot6")
+     */
+    private collectStaticChildInstances;
+    /**
+     * Return the concatenated text content of a list of IR nodes when
+     * every node is plain text; otherwise null.
+     */
+    private extractTextChildren;
+    /**
+     * Render JSX children to a Go-template-ready HTML fragment when
+     * children are non-text but produce purely-static HTML (no Go
+     * template actions). Returns null when:
+     *   - children are absent or text-only (handled by extractTextChildren), or
+     *   - the rendered fragment contains any `{{...}}` action — passing
+     *     such a fragment through `template.HTML` and the parent's
+     *     `{{.Children}}` would output the actions verbatim instead of
+     *     evaluating them, which is worse than the existing
+     *     "drop children" fallback. Dynamic / component-bearing children
+     *     stay on the drop path until a re-evaluation hook lands.
+     */
+    private extractHtmlChildren;
+    private collectStaticChildInstancesRecursive;
+    /**
+     * Collect top-level (non-loop) JSX intrinsic-element spread slots
+     * from the IR (#1407). Loop-internal spreads are skipped — they
+     * emit the bag inline via the loop's iteration variable in
+     * `elementAttrEmitter.emitSpread`, so they don't need a Props
+     * struct field.
+     *
+     * Walks the IR tree, descending into elements, fragments,
+     * conditionals, providers, async, and components, but stopping at
+     * loop bodies. Each `IRElement.attrs[i].value` of kind `'spread'`
+     * that has a `slotId` becomes one `SpreadSlotInfo` entry.
+     */
+    private collectSpreadSlots;
+    /**
+     * Decide how a spread bag should be plumbed onto the Input/Props
+     * structs (#1407 follow-up). A bare-identifier spread that
+     * matches the component's `restPropsName` is open-ended (Go's
+     * static typing can't enumerate the keys), so the caller must
+     * supply the bag via an Input-side `map[string]any` field. Every
+     * other shape — signal getter, `propsObjectName`, plain
+     * propsParam, object literal — can be constructed inline in
+     * `NewXxxProps` from compile-time-known data.
+     *
+     * Reads `this.restPropsName` (stashed at `generate()` entry)
+     * rather than receiving the IR per-call — matches the existing
+     * `this.propsObjectName` / `this.componentName` storage pattern.
+     */
+    private classifySpreadBagSource;
+    private collectSpreadSlotsRecursive;
+    /**
+     * Parse a JS object-literal source text (the raw string captured
+     * for a signal's `initialValue` or a spread expression's argument)
+     * into a Go `map[string]any{...}` literal source (#1407).
+     *
+     * Supports a deliberately conservative subset so the Go output is
+     * a 1:1 translation of the JS source: string/number/boolean/null
+     * values keyed by identifier or string-literal keys. Returns null
+     * for unsupported shapes (nested objects, computed values,
+     * function calls, spread elements) — callers fall back to BF101.
+     */
+    private parseJsObjectLiteralToGoMap;
+    /**
+     * Build a Go expression for a JSX spread bag's initial value, to
+     * be placed inside `NewXxxProps`'s return literal (#1407).
+     *
+     * Supported shapes:
+     *   - Signal-getter call (e.g. `attrs()`): look up the signal,
+     *     parse its `initialValue` as a JS object literal, and emit a
+     *     Go `map[string]any{...}` literal.
+     *   - Bare identifier matching a destructured `propsParam` (e.g.
+     *     `function({ extras }: P) { <el {...extras}/> }`): emit
+     *     `in.<FieldName>` — works when the prop's Go type is a map
+     *     type the bag is assignable to.
+     *   - Bare identifier matching `propsObjectName` (SolidJS-style
+     *     `function(props: P) { <el {...props}/> }`): enumerate the
+     *     analyzer-extracted `propsParams` into an inline
+     *     `map[string]any{...}` literal so each typed Input field
+     *     surfaces as a bag key (#1407 follow-up).
+     *   - Bare identifier matching `restPropsName` (the destructured-
+     *     rest pattern `function({a, ...rest}: P) { <el {...rest}/> }`):
+     *     emit `in.<slotId>` against the `map[string]any` Input field
+     *     that `generateInputStruct` adds for `input-bag` slots. The
+     *     caller (parent component or test harness) populates the
+     *     bag with the open-ended rest values (#1407 follow-up).
+     *
+     * Returns null for unsupported shapes so the caller can raise a
+     * narrowed BF101 with the offending expression.
+     */
+    private buildSpreadInitializer;
+    /**
+     * Convert JavaScript initial value to Go value for NewXxxProps function.
+     * References to props params are converted to in.FieldName format.
+     */
+    private convertInitialValue;
+    /**
+     * Convert TypeInfo to Go type string.
+     * If type is unknown, tries to infer from defaultValue.
+     */
+    private typeInfoToGo;
+    /**
+     * Get signal's initial value as Go code.
+     * Handles both literal values (0, true, "str") and props references (initial).
+     *
+     * (#1423) When the signal references a prop via `props.X ?? N` and
+     * the caller hoisted a fallback variable for `X`, return the hoisted
+     * variable's name so the memo inherits the signal-time fallback.
+     */
+    private getSignalInitialValueAsGo;
+    /**
+     * Resolve dynamic prop value (e.g., signal/memo getter calls) to Go initial value.
+     * Handles expressions like `count()` → signal's initial value
+     */
+    /**
+     * Convert a template literal's parsed parts into a Go expression of
+     * type `string`, evaluated in `NewXxxProps` scope (where destructured
+     * prop refs resolve via `in.FieldName`). Returns null when any part
+     * is not representable in static Go code so the caller can fall back
+     * to `resolveDynamicPropValue` (which handles the simpler shapes).
+     *
+     * Supported parts:
+     *   - `string`: emit as a Go string literal.
+     *   - `lookup`: `${MAP[KEY]}` against a `Record<T, string>` literal —
+     *     emit an IIFE that switches on the key prop and returns the
+     *     matching case (empty when no case matches). The key must be a
+     *     bare prop identifier today; other key shapes opt out.
+     *
+     * `ternary` is intentionally left unsupported — the existing
+     * element-attribute path handles it via Go template `{{if}}` syntax,
+     * and component-prop-via-ternary cases are rarer and can be added
+     * incrementally.
+     */
+    private templatePartsToGoCode;
+    private resolveDynamicPropValue;
+    /**
+     * Compute the initial value for a memo based on its computation and signal initial values.
+     * Handles simple cases like `() => count() * 2` → `in.Initial * 2`
+     * Also handles props.xxx patterns like `() => props.value * 10` → `in.Value * 10`
+     *
+     * (#1423) When `propFallbackVars` carries a hoisted variable for the
+     * referenced prop, substitute it for `in.FieldName` so the memo
+     * inherits the signal-time `??` fallback.
+     */
+    private computeMemoInitialValue;
+    /**
+     * Infer the Go type for a memo based on its computation and dependencies.
+     */
+    private inferMemoType;
+    /**
+     * Infer Go type from a JavaScript value literal.
+     */
+    private inferTypeFromValue;
+    /**
+     * (#1423) Hoisted-variable record for a prop with a signal-time
+     * `??` fallback. The same record is referenced from the prop field
+     * loop, the signal field loop, and the memo computation path.
+     */
+    private static EMPTY_PROP_FALLBACK_VARS;
+    /**
+     * (#1423) Walk signals to collect prop fallbacks. Skips props that
+     * already have a destructure-side default (`{ X = N }`) or signals
+     * whose fallback resolves to the type's Go zero value (no-op).
+     */
+    private collectPropFallbackVars;
+    /**
+     * (#1423) Parse a signal-time initial value of the form
+     * `props.X ?? <literal>` into the source prop name and the Go-formatted
+     * fallback. Returns null when:
+     *   - the expression isn't a `??` against a property access on
+     *     `propsObjectName`
+     *   - the fallback isn't a simple literal `goPropDefault` can translate
+     *
+     * The Go-adapter equivalent of the same parse already done by the
+     * static evaluator in `ssr-defaults.ts` — duplicated here because we
+     * need the original prop reference (not just the resolved value)
+     * to honour caller-supplied non-zero inputs.
+     */
+    private extractPropFallback;
+    /**
+     * Extract prop name from a signal's initialValue that uses props.xxx pattern.
+     * e.g., "props.initial ?? 0" → "initial", "props.checked" → "checked"
+     */
+    private extractPropNameFromInitialValue;
+    /** Go common initialisms that should be fully uppercased (https://go.dev/wiki/CodeReviewComments#initialisms) */
+    private static GO_INITIALISMS;
+    /**
+     * (#1423) Go reserved keywords. When we hoist a local var named after
+     * a JSX prop, the prop name could collide with one of these — append
+     * `_` until the name is free.
+     */
+    private static GO_KEYWORDS;
+    private capitalizeFieldName;
+    /**
+     * Convert a JavaScript literal value to Go literal syntax.
+     */
+    /**
+     * Translate a JSX param default (e.g. `'default'`, `0`, `false`) into
+     * the corresponding Go literal. Returns null when the default is
+     * absent or non-trivial (objects, arrow functions, etc.) — those
+     * fall back to letting Go's zero value win.
+     */
+    private goPropDefault;
+    /**
+     * Wrap an `in.X` reference in a Go expression that substitutes
+     * `fallback` when the input is the zero value for its type. We pick
+     * the comparison based on the fallback literal's shape.
+     *
+     * Asymmetry on bool defaults is intentional and worth flagging:
+     *   - For a `true` default, the generated expression is
+     *     `(in.X || true)` — which is **always `true`**. Go has no
+     *     unset-vs-explicit-false distinction at the struct-field level,
+     *     so any caller wanting to thread `false` through has to set it
+     *     after `NewXxxProps` rather than via the input struct.
+     *   - For a `false` default, the Go zero value already matches, so
+     *     the helper is a no-op (returns `ref` unchanged).
+     * Numeric `0` defaults are similarly indistinguishable from "unset"
+     * and pass through as the zero value; non-zero numeric defaults
+     * substitute, matching the JSX behavior of `(initial = 5) => ...`.
+     */
+    private applyGoFallback;
+    private goLiteral;
+    /**
+     * Public entry point for node rendering. Delegates to the shared
+     * `IRNodeEmitter` dispatcher (#1290 step 1); per-kind logic lives in
+     * the `IRNodeEmitter` methods below.
+     */
+    renderNode(node: IRNode, ctx?: GoRenderCtx): string;
+    emitElement(node: IRElement, _ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    emitText(node: IRText): string;
+    emitExpression(node: IRExpression): string;
+    emitConditional(node: IRConditional, _ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    emitLoop(node: IRLoop, _ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    emitComponent(node: IRComponent, ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    emitFragment(node: IRFragment, _ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    emitSlot(node: IRSlot): string;
+    emitIfStatement(node: IRIfStatement, ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    emitProvider(node: IRProvider, _ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    emitAsync(node: IRAsync, _ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
+    renderElement(element: IRElement): string;
+    renderExpression(expr: IRExpression): string;
+    /**
+     * Render a client-only conditional as comment markers.
+     * Used when @client directive is applied to an unsupported conditional.
+     * The condition is evaluated on the client side via insert().
+     */
+    private renderClientOnlyConditional;
+    /**
+     * Render a ParsedExpr to Go template syntax via the shared
+     * dispatcher (#1250 phase 1). The per-kind logic lives in the
+     * `ParsedExprEmitter` methods below; this method is a thin wrapper
+     * so existing call sites keep working.
+     */
+    private renderParsedExpr;
+    identifier(name: string): string;
+    literal(value: string | number | boolean | null, literalType: LiteralType): string;
+    call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string;
+    binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    unary(op: string, argument: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    logical(op: '&&' | '||' | '??', left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    conditional(test: ParsedExpr, consequent: ParsedExpr, alternate: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    templateLiteral(parts: TemplatePart[], emit: (e: ParsedExpr) => string): string;
+    arrowFn(param: string, _body: ParsedExpr, _emit: (e: ParsedExpr) => string): string;
+    arrayLiteral(elements: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    higherOrder(method: HigherOrderMethod, object: ParsedExpr, param: string, predicate: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    arrayMethod(method: ArrayMethod, object: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
+    sortMethod(method: 'sort' | 'toSorted', object: ParsedExpr, comparator: SortComparator, emit: (e: ParsedExpr) => string): string;
+    unsupported(raw: string, _reason: string): string;
+    /**
+     * Extract field name and negation from a simple predicate.
+     * t => t.done → { field: "Done", negated: false }
+     * t => !t.done → { field: "Done", negated: true }
+     */
+    private extractFieldPredicate;
+    /**
+     * Extract field name and value from an equality predicate.
+     * Extends extractFieldPredicate to also handle equality comparisons.
+     *
+     * t.done → { field: "Done", value: "true" }
+     * !t.done → { field: "Done", value: "false" }
+     * u.id === selectedId() → { field: "Id", value: <rendered expr> }
+     * selectedId() === u.id → same (supports both operand orders)
+     */
+    private extractEqualityPredicate;
+    /**
+     * Render a higher-order expression (filter, every, some, find, findIndex) to Go template.
+     * Returns null if the expression is not supported.
+     *
+     * @param expr - The higher-order expression
+     * @param renderArray - Function to render the array expression (allows recursion via different methods)
+     */
+    private renderHigherOrderExpr;
+    /**
+     * Render find()/findIndex() with complex predicates using {{range}}{{if}}...{{break}} blocks.
+     * Falls back from bf_find/bf_find_index when extractEqualityPredicate returns null.
+     * Reuses renderFilterExpr for condition rendering.
+     *
+     * @param expr - The higher-order find/findIndex expression
+     * @param renderArray - Function to render the array expression
+     * @param propertyAccess - Optional property to access on the found element (for find().property)
+     */
+    private renderFindTemplateBlock;
+    /**
+     * Render every()/some() with complex predicates using {{range}}{{if}} with variable reassignment.
+     * Falls back from bf_every/bf_some when extractFieldPredicate returns null.
+     * Reuses renderFilterExpr for condition rendering.
+     *
+     * every: start true, set false on first failure, break early
+     * some: start false, set true on first match, break early
+     *
+     * @param expr - The higher-order every/some expression
+     * @param renderArray - Function to render the array expression
+     */
+    private renderEverySomeTemplateBlock;
+    /**
+     * Negate a Go template condition.
+     * Wraps in `not (...)` when the condition is a Go function call (eq, ne, gt, etc.),
+     * otherwise uses `not condition`.
+     */
+    private negateGoCondition;
+    /**
+     * Render .length on a filter higher-order expression.
+     * e.g., todos().filter(t => !t.done).length → len (bf_filter .Todos "Done" false)
+     *
+     * @param filterExpr - The filter higher-order expression
+     * @param renderArray - Function to render the array expression
+     */
+    private renderFilterLengthExpr;
+    /**
+     * Render a predicate expression for use in Go template {{if}} conditions.
+     * Substitutes the loop parameter (e.g., 't' in 't.done') with dot notation.
+     */
+    private renderPredicateCondition;
+    /**
+     * Check if expression needs parentheses when used in and/or.
+     */
+    private needsParens;
+    /**
+     * Render block body filter into a single Go template condition.
+     *
+     * Example block body:
+     * ```
+     * filter(t => {
+     *   const f = filter()
+     *   if (f === 'active') return !t.done
+     *   if (f === 'completed') return t.done
+     *   return true
+     * })
+     * ```
+     *
+     * Becomes:
+     * ```
+     * or (and (eq $.Filter "active") (not .Done))
+     *    (and (eq $.Filter "completed") .Done)
+     *    (and (ne $.Filter "active") (ne $.Filter "completed"))
+     * ```
+     */
+    private renderBlockBodyCondition;
+    /**
+     * Recursively collect all return paths through the statements.
+     * Returns an array of ReturnPath objects.
+     */
+    private collectReturnPaths;
+    /**
+     * Build a condition for a single return path.
+     */
+    private buildSinglePathCondition;
+    /**
+     * Build an OR condition from multiple return paths.
+     */
+    private buildOrCondition;
+    /**
+     * Render multiple conditions combined with AND.
+     */
+    private renderConditionsAnd;
+    /**
+     * Unified method for rendering filter predicate expressions.
+     * Used for both expression body (t => !t.done) and block body filters.
+     *
+     * @param expr - The parsed expression to render
+     * @param param - The loop parameter name (e.g., 't' in filter(t => ...))
+     * @param localVarMap - Optional map of local variables to signal names (for block body)
+     */
+    private renderFilterExpr;
+    private renderFilterExprNode;
+    /**
+     * Check if a ParsedExpr will render as a Go template function call.
+     * Used to determine if parentheses are needed around the expression.
+     */
+    private isGoFunctionCall;
+    /**
+     * Render a branch of a conditional expression.
+     * String literals render as bare text (no quotes).
+     * Nested conditionals render as complete {{if}}...{{end}} blocks.
+     */
+    private renderConditionalBranch;
+    /**
+     * Check if a ParsedExpr renders to a Go template function call that needs parentheses.
+     * In Go templates, function calls like `len .X` or `bf_add .A .B` need parentheses
+     * when used as arguments to comparison operators (eq, gt, lt, etc.).
+     */
+    private needsParensInGoTemplate;
+    /**
+     * Convert a JS expression to Go template syntax.
+     */
+    private convertExpressionToGo;
+    /**
+     * Create a source location for error reporting.
+     */
+    private makeLoc;
+    private renderIfStatement;
+    renderConditional(cond: IRConditional): string;
+    /**
+     * Convert a JS condition to Go template condition syntax.
+     * Returns { condition, preamble } where preamble contains template blocks
+     * that must be emitted before the {{if}} (e.g., every/some range blocks).
+     */
+    private convertConditionToGo;
+    /**
+     * Render a ParsedExpr as a Go template condition.
+     */
+    private renderConditionExpr;
+    renderLoop(loop: IRLoop): string;
+    /**
+     * Find the first component child in a list of nodes
+     */
+    private findChildComponent;
+    renderComponent(comp: IRComponent, ctx?: {
+        isRootOfClientComponent?: boolean;
+    }): string;
+    /**
+     * Render a Portal component by adding its children to PortalCollector.
+     * Portal content is rendered at </body> instead of inline.
+     *
+     * For static content: uses simple string literal with Add()
+     * For dynamic content: uses bfPortalHTML() to parse and execute template string
+     */
+    private renderPortalComponent;
+    private renderFragment;
+    private renderSlot;
+    renderAsync(node: IRAsync): string;
+    private escapeGoString;
+    /**
+     * AttrValue lowering for intrinsic-element attributes (Go templates).
+     * Per-kind logic that used to live in a `switch (v.kind)` inside
+     * `renderAttributes`; routed through the shared dispatcher so a new
+     * AttrValue kind becomes a TS compile error here (#1290 step 2).
+     *
+     * Components have no equivalent AttrValueEmitter on this adapter:
+     * Go templates pass component-instance props as Go struct fields
+     * (`collectStaticChildInstances` builds them), not as string-emitted
+     * markup, so that path does not share a contract with the
+     * intrinsic-attribute one.
+     */
+    private readonly elementAttrEmitter;
+    private renderAttributes;
+    /**
+     * Replace `${EXPR}` JS-template-literal interpolations in a static
+     * string part with Go template actions (`{{<expr-as-go>}}`), and
+     * HTML-escape the surrounding literal text so embedded characters
+     * don't break the attribute quoting we render into.
+     *
+     * UnoCSS arbitrary-value classes like `[class*="size-"]:size-4`
+     * legitimately contain `"`, which would otherwise terminate the
+     * `class="..."` attribute early and produce invalid HTML / a
+     * `html/template` error at execution time.
+     *
+     * The interpolation parser is brace-depth aware: nested `{...}`
+     * inside an expression (object literals, nested template literals,
+     * etc.) are skipped past correctly so the closing brace of the
+     * outer `${...}` is found. An unterminated `${` falls back to
+     * literal text — better to output something than swallow it.
+     */
+    private substituteJsInterpolations;
+    /**
+     * HTML-attribute-safe escaping for double-quoted attribute values.
+     * `&`/`"`/`<` are non-negotiable — without them the surrounding
+     * `class="..."` quoting breaks (a real bug we hit with UnoCSS's
+     * `[class*="size-"]`). `>`/`'` are belt-and-suspenders: HTML5
+     * permits both inside double-quoted attrs, but Go's `html/template`
+     * lexer is contextual and we'd rather not bet on its edge cases
+     * matching ours forever.
+     */
+    private escapeAttrText;
+    private renderTemplateLiteralParts;
+    renderScopeMarker(_instanceIdExpr: string): string;
+    renderSlotMarker(slotId: string): string;
+    renderCondMarker(condId: string): string;
+    private wrapWithCondMarker;
+}
+export declare const goTemplateAdapter: GoTemplateAdapter;
+export {};
+//# sourceMappingURL=go-template-adapter.d.ts.map