@barefootjs/go-template 0.16.0 → 0.17.0

package/dist/adapter/lib/compile-state.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Per-compile mutable state for the Go html/template adapter. The adapter is a
+ * reused singleton; everything established (and reset) per `generate()` /
+ * `generateTypes()` run lives here. The adapter holds a single `CompileState`
+ * and resets its members at the start of each compile.
+ *
+ * NOT included (deliberately): cross-compile child-shape registries
+ * (`childComponentShapes`, `childContextConsumers`, populated before a parent
+ * compiles), the render-recursion cursor stacks (`loopParamStack`,
+ * `filterExprDepth`, …), and constant config (`options`, `templatePrimitives`).
+ */
+import type { CompilerError, ContextConsumer, IRMetadata, IRNode, LoweringMatcher, MemoInfo, TypeDefinition, TypeInfo } from '@barefootjs/jsx';
+export declare class CompileState {
+    componentName: string;
+    errors: CompilerError[];
+    /** Component-scope derived consts referenced by the template during rendering
+     *  (e.g. `root` → `.Root`). `generateTypes` emits a computed field for each
+     *  that's resolvable and non-colliding. */
+    referencedDerivedConsts: Set<string>;
+    templateVarCounter: number;
+    /**
+     * Companion `{{define "<Component>__children_<slot>"}}` blocks queued while
+     * rendering the template body. Flushed after the main define in `generate()`.
+     */
+    pendingChildrenDefines: Array<{
+        name: string;
+        content: string;
+    }>;
+    propsObjectName: string | null;
+    /**
+     * 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.
+     */
+    restPropsName: string | null;
+    /**
+     * Module-scope pure string-literal constants (`const X = 'literal'` at
+     * file top-level), keyed by name → resolved literal value. When an identifier
+     * resolves to one of these, the adapter inlines the literal value instead of
+     * emitting a struct-field reference.
+     */
+    moduleStringConsts: Map<string, string>;
+    /**
+     * All local constants (module + function-scope) from the IR, retained for
+     * the lifetime of `generate()` so the memo-computation path can resolve
+     * `Record`-index lookups without re-threading the full `ir` through helpers.
+     */
+    localConstants: IRMetadata['localConstants'];
+    /**
+     * Names of component-scope arrow-const helpers (`const sortClass = …`),
+     * eligible for call-site inlining.
+     */
+    localHelperNames: Set<string>;
+    /** The current IR's memos, stashed like `localConstants` so nested memo
+     *  resolution can recurse without threading the list through every signature.
+     *  Full `MemoInfo` so consumers can read the analyzer-attached `parsed` tree. */
+    currentMemos: MemoInfo[];
+    /** Full type definitions from the current IR, stashed for loop-datum field resolution. */
+    currentTypeDefinitions: TypeDefinition[];
+    /**
+     * `useContext(...)` consumers in the component being generated. Each becomes
+     * a struct field defaulted to the `createContext` default.
+     */
+    contextConsumers: ContextConsumer[];
+    /**
+     * Local binding names the request-scoped `searchParams()` env signal is
+     * imported under (handles `import { searchParams as sp }`).
+     */
+    searchParamsLocals: Set<string>;
+    /**
+     * Call-lowering matchers active for this component (#2057), bound to its
+     * metadata at init via `prepareLoweringMatchers`. Each maps a recognised call
+     * to a backend-neutral `LoweringNode` the adapter renders. Covers both userland
+     * plugins and the compiler's built-in plugins (e.g. `queryHref` → `bf_query`,
+     * #2042), so there is no separate per-API recognition path.
+     */
+    loweringMatchers: LoweringMatcher[];
+    /**
+     * Prop NAMES whose resolved Go struct-field type is exactly `interface{}`
+     * — i.e. nillable. Used by the attribute emitter to omit a dynamic attribute
+     * whose value is a bare reference to such a prop when it's nil.
+     */
+    nillablePropNames: Set<string>;
+    /** Component root scope element(s) — each carries `data-key` for a keyed loop
+     *  item. */
+    rootScopeNodes: Set<IRNode>;
+    /** Array-memo name → the handler-filled loop slice field its `.map()` feeds
+     *  (e.g. `visible` → `PostListItems`). Lets `<memo>().length` lower to the
+     *  slice's length instead of a nil/unset memo field. */
+    memoBackedLoopSlice: Map<string, string>;
+    /** Set during type generation when any emit references
+     *  `template.HTML(...)`; toggles the `"html/template"` import. */
+    usesHtmlTemplate: boolean;
+    /** Set during type generation when any emit references `fmt.Sprint(...)`;
+     *  toggles the `"fmt"` import. */
+    usesFmt: boolean;
+    /** Local type names resolved from typeDefinitions (populated during generateTypes). */
+    localTypeNames: Set<string>;
+    /** Local type aliases mapping type name to base type (e.g., Filter → 'string'). */
+    localTypeAliases: Map<string, string>;
+    /**
+     * Per-struct field map (type name → source TS key → Go field name), populated
+     * during generateTypes. The object-literal baker consults this so a baked
+     * struct literal only names fields the generated struct actually declares.
+     */
+    localStructFields: Map<string, Map<string, string>>;
+    /**
+     * Synthesised array types for untyped object-array signals (signal getter →
+     * `[]SynthStruct` TypeInfo), populated during generateTypes.
+     */
+    synthStructTypes: Map<string, TypeInfo>;
+    /** Set when a constructor-context lowering emits a `strings.` call, so
+     *  `strings` is added to the generated types file's import block. */
+    needsStringsImport: boolean;
+}
+//# sourceMappingURL=compile-state.d.ts.map

package/dist/adapter/lib/compile-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-state.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/compile-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,UAAU,EACV,MAAM,EACN,eAAe,EACf,QAAQ,EACR,cAAc,EACd,QAAQ,EACT,MAAM,iBAAiB,CAAA;AAExB,qBAAa,YAAY;IAGvB,aAAa,EAAE,MAAM,CAAK;IAC1B,MAAM,EAAE,aAAa,EAAE,CAAK;IAE5B;;+CAE2C;IAC3C,uBAAuB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IAEhD,kBAAkB,EAAE,MAAM,CAAI;IAE9B;;;OAGG;IACH,sBAAsB,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAK;IAErE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAO;IAErC;;;;OAIG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAO;IAEnC;;;;;OAKG;IACH,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAY;IAEnD;;;;OAIG;IACH,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAK;IAEjD;;;OAGG;IACH,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IAEzC;;qFAEiF;IACjF,YAAY,EAAE,QAAQ,EAAE,CAAK;IAE7B,0FAA0F;IAC1F,sBAAsB,EAAE,cAAc,EAAE,CAAK;IAE7C;;;OAGG;IACH,gBAAgB,EAAE,eAAe,EAAE,CAAK;IAExC;;;OAGG;IACH,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IAE3C;;;;;;OAMG;IACH,gBAAgB,EAAE,eAAe,EAAE,CAAK;IAExC;;;;OAIG;IACH,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IAE1C;gBACY;IACZ,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IAEvC;;4DAEwD;IACxD,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAY;IAIpD;sEACkE;IAClE,gBAAgB,EAAE,OAAO,CAAQ;IAEjC;sCACkC;IAClC,OAAO,EAAE,OAAO,CAAQ;IAExB,uFAAuF;IACvF,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAY;IAEvC,mFAAmF;IACnF,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAY;IAEjD;;;;OAIG;IACH,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAY;IAE/D;;;OAGG;IACH,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAY;IAEnD;yEACqE;IACrE,kBAAkB,UAAQ;CAC3B"}

package/dist/adapter/lib/constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Compile-time constant tables for the Go html/template adapter.
+ */
+import type { PrimitiveSpec } from "./types.ts";
+/**
+ * Single source of truth for the Go adapter's template-primitive surface. Each
+ * entry pairs the expected arity with the emit function so the two derived maps
+ * (`templatePrimitives` and `templatePrimitiveArities`) can't drift out of sync.
+ */
+export declare const GO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/adapter/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAG/C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAWhE,CAAA"}

package/dist/adapter/lib/go-emit.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Go html/template emit helpers: string escaping, argument wrapping, `bf_*`
+ * runtime-helper call construction, and JSX-literal → Go-literal lowering.
+ * Pure free functions — none read adapter instance state.
+ */
+import type { SortComparator, SupportResult, ParsedExpr } from '@barefootjs/jsx';
+/** Escape a value for embedding in a Go-template double-quoted string. */
+export declare function escapeGoString(s: string): string;
+/**
+ * Wrap a rendered Go template fragment in parens when it would otherwise parse
+ * as multiple sibling args of an enclosing prefix call. A bare identifier /
+ * dotted path / quoted literal stays uncluttered; anything containing
+ * whitespace (a call, `len ...`) gets `(...)` so `bf_join (...) bf_trim .Raw`
+ * doesn't degrade to four args of `bf_join`.
+ */
+export declare function wrapIfMultiToken(rendered: string): string;
+/**
+ * Parenthesize a compound Go template argument (`or .Checked false`) so a
+ * primitive call reads it as ONE argument — unwrapped, the parser splits it
+ * into three and `bf_string` fails with "want 1 got 3".
+ */
+export declare function wrapGoArg(arg: string): string;
+/**
+ * Emit the `bf_sort` call:
+ *
+ *   bf_sort <recv> (<keyKind> <keyName> <compareType> <direction>)+
+ *
+ *   keyKind:      "self" | "field"
+ *   keyName:      "" when keyKind=self; capitalised field name otherwise
+ *   compareType:  "numeric" | "string" | "auto"
+ *   direction:    "asc" | "desc"
+ *
+ * The 4-string group repeats once per comparison key: a simple comparator emits
+ * one group; a `||`-chained multi-key comparator emits one per operand, applied
+ * in order as tie-breakers by the variadic `bf_sort` runtime. Capitalisation
+ * mirrors the Go struct-field convention so the runtime's reflect lookup
+ * matches without a recapitalise step.
+ */
+export declare function emitBfSort(recv: string, c: SortComparator): string;
+/**
+ * Emit a `.sort(cmp)` via the evaluator (#2018): the comparator body travels as
+ * serialized-ParsedExpr JSON, evaluated per comparison against `{paramA, paramB,
+ * …captured}`. Returns null when the comparator can't be evaluated (e.g. a
+ * `localeCompare` body — `serializeParsedExpr` refuses it), so the caller falls
+ * back to the structured `bf_sort`. A `||`-chained multi-key comparator needs no
+ * special handling — JS `0 || next` is exactly the tie-break semantics.
+ */
+export declare function emitSortEval(recv: string, body: ParsedExpr, params: string[], emit: (e: ParsedExpr) => string): string | null;
+/**
+ * Emit a `.reduce(fn, init)` via the evaluator (#2018): the reducer body travels
+ * as serialized-ParsedExpr JSON, folded over the receiver from `init`. Returns
+ * null when the body can't be evaluated, or when `init` isn't a string/number
+ * literal (a non-literal seed has no template-time value). A numeric seed is
+ * passed through `bf_number` (handles any decimal incl. negative / float); a
+ * string seed as a quoted string.
+ */
+export declare function emitReduceEval(recv: string, body: ParsedExpr, params: string[], init: ParsedExpr, direction: 'left' | 'right', emit: (e: ParsedExpr) => string): string | null;
+/**
+ * Emit a higher-order predicate call via the evaluator (#2018, P2): the
+ * predicate body (already a `ParsedExpr` on the `higher-order` IR node) travels
+ * as serialized-ParsedExpr JSON, evaluated per element against `{param,
+ * …captured}`. Generalizes the field-equality / truthiness catalogues of
+ * `bf_filter` / `bf_find` / `bf_every` / `bf_some` to any pure predicate body.
+ * Returns null when the predicate is outside the evaluator surface (e.g. a
+ * method-call predicate — `serializeParsedExpr` refuses it), so the caller
+ * falls back to the structured helper / template-block path.
+ *
+ *   <func> <recv> "<json>" "<param>" [<extraArgs>…] <env>
+ *
+ * `extraArgs` are inserted between the param name and the env — used for the
+ * find / findIndex `forward` bool (`true` = find / findIndex, `false` =
+ * findLast / findLastIndex).
+ */
+export declare function emitPredicateEval(funcName: string, recv: string, predicate: ParsedExpr, param: string, emit: (e: ParsedExpr) => string, extraArgs?: string[]): string | null;
+/**
+ * Emit a `.flatMap(proj)` via the evaluator (#2018, P3): the projection body
+ * (e.g. `i.tags` / `[i.a, i.b]`) is serialized and evaluated per element by
+ * `bf_flat_map_eval`, which flattens the results one level. Returns null when
+ * the projection is outside the evaluator surface (→ caller pushes BF101).
+ */
+export declare function emitFlatMapEval(recv: string, body: ParsedExpr, param: string, emit: (e: ParsedExpr) => string): string | null;
+/**
+ * Make an equality comparison string-tolerant when exactly one side is a Go
+ * string literal: JS `sorted === 'asc'` is loosely false for `sorted = false`,
+ * but Go's template `eq` ERRORS on bool-vs-string (`incompatible types for
+ * comparison`). Routing the non-literal side through `bf_string` preserves JS
+ * comparison semantics for every concrete type while leaving same-kind
+ * comparisons untouched.
+ */
+export declare function stringTolerantEqOperands(l: string, r: string): [string, string];
+export declare const GO_REMEDIATION_OPTIONS = "Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code";
+export declare function buildUnsupportedSuggestion(support: SupportResult): string;
+/**
+ * Translate a JSX param default (e.g. `'default'`, `0`, `false`) into the
+ * corresponding Go literal.
+ *
+ * @returns the Go literal, or `null` when the default is absent or non-trivial
+ *   (objects, arrow functions, …) — caller then lets Go's zero value win.
+ */
+export declare function goPropDefault(defaultValue: string | undefined): string | null;
+/**
+ * Wrap an `in.X` reference in a Go expression that substitutes `fallback` when
+ * the input is the zero value for its type; the comparison is picked from the
+ * fallback literal's shape.
+ *
+ * Asymmetry on bool/zero defaults is intentional (Go has no
+ * unset-vs-explicit-false distinction at the struct-field level):
+ *   - `true` default → `(in.X || true)`, which is ALWAYS `true`; a caller
+ *     wanting `false` must set it after `NewXxxProps`, not via the input struct.
+ *   - `false` / `0` default → matches the Go zero value, so this is a no-op
+ *     (returns `ref` unchanged).
+ * Non-zero numeric defaults substitute, matching JSX `(initial = 5) => …`.
+ */
+export declare function applyGoFallback(ref: string, fallback: string): string;
+/** Convert a JavaScript literal value to Go literal syntax. */
+export declare function goLiteral(value: string): string;
+//# sourceMappingURL=go-emit.d.ts.map

package/dist/adapter/lib/go-emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go-emit.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/go-emit.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAKhF,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,cAAc,GAAG,MAAM,CAMlE;AAiBD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,GAAG,IAAI,CAWf;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,GAAG,OAAO,EAC3B,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,GAAG,IAAI,CAqBf;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,UAAU,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,EAC/B,SAAS,GAAE,MAAM,EAAO,GACvB,MAAM,GAAG,IAAI,CAMf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAC9B,MAAM,GAAG,IAAI,CAKf;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAO/E;AAID,eAAO,MAAM,sBAAsB,uGACmE,CAAA;AAOtG,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAIzE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAe7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUrE;AAED,+DAA+D;AAC/D,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAW/C"}

package/dist/adapter/lib/go-naming.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Go identifier / field-name conventions: the single source of truth for
+ * capitalisation, initialism handling, and slot/loop-key → Go field-path
+ * lowering. Pure helpers — none read adapter instance state.
+ */
+/** Matches a bare Go identifier (no dots, no brackets). */
+export declare const GO_IDENTIFIER: RegExp;
+/** Go common initialisms that should be fully uppercased (https://go.dev/wiki/CodeReviewComments#initialisms) */
+export declare const GO_INITIALISMS: Set<string>;
+/**
+ * Go reserved keywords. When hoisting a local var named after a JSX prop, a
+ * collision with one of these is resolved by appending `_` until free.
+ */
+export declare const GO_KEYWORDS: Set<string>;
+/**
+ * Capitalise a name for use as a Go template field projection. A whole-word
+ * Go initialism uppercases entirely (`id` → `ID`, `url` → `URL`) so the
+ * `bf_sort` / `bf_reduce` reflect lookup resolves the generated exported
+ * field instead of silently folding a zero value.
+ */
+export declare function capitalize(s: string): string;
+/** Capitalise a JSX prop / field name to its exported Go struct field name. */
+export declare function capitalizeFieldName(name: string): string;
+/**
+ * Convert a slot ID (e.g., 's6') to a Go struct field suffix (e.g., 'Slot6').
+ * Keeps field names human-readable regardless of the internal slot ID format.
+ */
+export declare function slotIdToFieldSuffix(slotId: string): string;
+/**
+ * Lower a keyed-loop `key` expression to the Go field path on the loop's range
+ * variable (always `item` in the generated `for i, item := range …`), e.g.
+ * `item.label` → `item.Label`.
+ *
+ * @returns `null` for a non-simple key (computed expression, whole-element key,
+ *   mismatched param) — caller then skips `data-key` rather than emit
+ *   something that won't compile.
+ */
+export declare function loopKeyToGoFieldPath(key: string | undefined, param: string | undefined): string | null;
+//# sourceMappingURL=go-naming.d.ts.map

package/dist/adapter/lib/go-naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go-naming.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/go-naming.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2DAA2D;AAC3D,eAAO,MAAM,aAAa,QAA6B,CAAA;AAEvD,iHAAiH;AACjH,eAAO,MAAM,cAAc,aAIzB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,aAKtB,CAAA;AAEF;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAM5C;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAS1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQtG"}

package/dist/adapter/lib/ir-scope.d.ts

@@ -0,0 +1,13 @@
+/**
+ * IR traversal helpers for the Go html/template adapter. Pure functions over
+ * the IR tree — no adapter instance state.
+ */
+import type { IRNode } from '@barefootjs/jsx';
+/**
+ * Collect the component's root scope element node(s) — the elements that become
+ * the rendered root and so carry `data-key` for a keyed loop item. A plain
+ * element root is itself; an `if-statement` (early-return) root contributes the
+ * top element of each branch, since exactly one renders at runtime.
+ */
+export declare function collectRootScopeNodes(node: IRNode): Set<IRNode>;
+//# sourceMappingURL=ir-scope.d.ts.map

package/dist/adapter/lib/ir-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-scope.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/ir-scope.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAA6B,MAAM,iBAAiB,CAAA;AAExE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAiB/D"}

package/dist/adapter/lib/types.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Internal type definitions for the Go html/template adapter: the adapter's
+ * intermediate bookkeeping shapes (nested-component info, static child
+ * instances, spread slots, ctor-lowering scope, …) plus the public
+ * `GoTemplateAdapterOptions`. Pure type surface — no behaviour.
+ */
+import type { IRLoopChildComponent, IRNode, IRProp, ParsedExpr, TypeInfo } 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.
+ */
+export type GoRenderCtx = {
+    isRootOfClientComponent?: boolean;
+};
+/**
+ * Extended nested component info that tracks whether the component
+ * comes from a dynamic (signal) array loop vs a static array loop.
+ */
+export interface NestedComponentInfo extends IRLoopChildComponent {
+    isDynamic: boolean;
+    isPropDerived: boolean;
+    /** The enclosing loop's `key` expression (e.g. `item.label`) and map param
+     *  name (`item`), so the loop-child init can stamp `data-key` per item. */
+    loopKey?: string;
+    loopParam?: string;
+    /** The loop body component's JSX children. Non-empty when those children need
+     *  a companion define rendered via `bf_with_children` + `bf_tmpl`. */
+    bodyChildren?: IRNode[];
+    /** The loop's array expression for baking (e.g. `sortedData()`) */
+    loopArray?: string;
+    /** Structured parse of `loopArray` (the loop's `array` string), carried so
+     *  scalar-literal loop typing reads the tree instead of re-parsing. */
+    loopArrayParsed?: ParsedExpr;
+    /** The enclosing loop's `markerId` (e.g. `l0`) for unique naming */
+    loopMarkerId?: string;
+    /** The loop item's TS type (`Payment` from `sortedData().map(payment => …)`),
+     *  resolved to Go struct fields for the wrapper struct's datum fields. */
+    loopItemType?: TypeInfo | null;
+}
+export interface StaticChildInstance {
+    name: string;
+    slotId: string;
+    props: IRProp[];
+    fieldName: string;
+    /** Concatenated text content from JSX children (e.g. `+1` for
+     *  `<Button>+1</Button>`). Null when children include any non-text node;
+     *  those take the `childrenHtml` path if purely static HTML, else dropped. */
+    childrenText: string | null;
+    /** Rendered Go-template fragment for purely-static, non-text JSX children,
+     *  forwarded via `Children: template.HTML(...)` so the child's
+     *  `{{or .Children ""}}` skips re-escaping. Null when children are text-only
+     *  or absent, OR when the fragment contains any `{{...}}` action (those
+     *  wouldn't re-evaluate through the parent's `{{.Children}}` read — kept on
+     *  the drop path). */
+    childrenHtml: string | null;
+    /** Go string-concat expression for hoisted-JSX children that carry a
+     *  `needsScope` root (`children={<span/>}`). The root's `bf-s` resolves to
+     *  the PARENT scope, so the fragment can't bake to a static string — the
+     *  runtime `scopeID` is spliced in (`"<span bf-s=\"" + scopeID + "\">x</span>"`).
+     *  Null when static `childrenHtml` already covers the children, or when any
+     *  other template action survives (genuinely dynamic — drop path). */
+    childrenScopedHtmlExpr: string | null;
+    /**
+     * Context values from enclosing `<Ctx.Provider value>` ancestors
+     * (`createContext` identifier → Go value literal), wired into this child
+     * slot's input against its own context-consumer fields. Empty/undefined when
+     * the child isn't under any provider.
+     */
+    contextBindings?: ReadonlyMap<string, string>;
+}
+/**
+ * Cross-component shape of a child component the parent renders.
+ * `paramNames` are the child's declared `propsParams`; `restBagField` is the
+ * Go field name of the child's open-ended rest bag
+ * (`Capitalize(restPropsName)`), or null when the child has no `...props` rest.
+ */
+export interface ChildComponentShape {
+    paramNames: Set<string>;
+    restBagField: string | null;
+    /**
+     * Child param names whose Go field is `map[string]interface{}` — an optional
+     * object/named-interface prop (`opts?: EmblaOptionsType`). A parent passing
+     * an inline object literal to such a param bakes it to a Go map literal so
+     * the keys round-trip faithfully.
+     */
+    mapTypedParamNames: Set<string>;
+}
+/**
+ * Top-level (non-loop) JSX intrinsic-element spread slot. The adapter emits one
+ * `Spread_<slotId> map[string]any` field on the component's Props struct and
+ * initialises it in `NewXxxProps` from the source JS expression. Loop-internal
+ * spreads don't appear here — they emit the bag inline via the loop's iteration
+ * variable instead.
+ *
+ * `bagSource` records how the bag is supplied:
+ * - `'inline'`: constructed inside `NewXxxProps` from compile-time-known data
+ *   (signal initial values, prop refs, propsObject enumeration). No Input field.
+ * - `'input-bag'`: provided by the caller as a `Spread_<slotId> map[string]any`
+ *   field on the Input struct (for `restPropsName` spreads whose keys are
+ *   open-ended and can't be enumerated under Go's static typing).
+ */
+export interface SpreadSlotInfo {
+    slotId: string;
+    expr: string;
+    /**
+     * Best-effort structured parse of `expr`. Lets the conditional inline-object
+     * spread lower from the tree instead of re-parsing `expr`. When absent, a
+     * non-conditional / `unsupported` tree falls through to the other spread
+     * shapes.
+     */
+    parsed: ParsedExpr | undefined;
+    templateExpr: string | undefined;
+    bagSource: 'inline' | 'input-bag';
+}
+/**
+ * Hoisted local var representing a prop with a signal-time `??` fallback. Used
+ * to share the fallback-applied value across the prop, signal, and memo fields.
+ */
+export interface PropFallbackVar {
+    /** Local variable name (typically the lowercase prop identifier). */
+    varName: string;
+    /** Capitalised Go field name on the `Input` struct. */
+    fieldName: string;
+    /** Go literal used when the input value equals its zero value. */
+    goFallback: string;
+    /** Go zero literal for the prop's type (`0`, `""`, etc.). */
+    zeroLiteral: string;
+}
+/**
+ * Scope for `lowerCtorExpr` — lowering a JS expression to Go in the
+ * `NewXxxProps` constructor context.
+ */
+export interface CtorLowerEnv {
+    /** Local names bound to `searchParams()` (`const sp = searchParams()`). */
+    searchParamsVars: Set<string>;
+    /** Helper-param name → its already-lowered Go argument, for inlining. */
+    params: Map<string, string>;
+    /** Component-scope const names currently being inlined (cycle guard). */
+    consts?: Set<string>;
+}
+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;
+}
+/**
+ * Single source of truth for the Go adapter's template-primitive surface. Each
+ * entry pairs the expected arity with the emit function so the two derived maps
+ * (`templatePrimitives` and `templatePrimitiveArities`) can't drift out of sync.
+ */
+export interface PrimitiveSpec {
+    arity: number;
+    emit: (args: string[]) => string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapter/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/types.ts"],"names":[],"mappings":"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"}

package/dist/adapter/memo/ctor-lowering.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Constructor-context expression lowering for derived-state memos.
+ *
+ * Free functions over a {@link GoEmitContext} that lower the narrow surface of
+ * JS expressions a derived-state memo needs into Go *code* (not template
+ * syntax) evaluated in the `NewXxxProps` constructor — e.g. a search-param read
+ * becomes `in.SearchParams.Get("k")`. `lowerCtorExpr` and `lowerCtorCond` are
+ * mutually recursive and set `state.needsStringsImport` when they emit a
+ * `strings.*` call. Anything outside the supported surface returns null so the
+ * caller can fall back to nil safely.
+ */
+import { type ParsedExpr } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+import type { CtorLowerEnv } from '../lib/types.ts';
+/**
+ * Lower a JS expression to a Go expression in the `NewXxxProps` constructor
+ * context. This is Go *code*, not template syntax — so a search-param read
+ * becomes `in.SearchParams.Get("k")` (method call), not the template's
+ * `.SearchParams.Get "k"`. Supports the narrow surface derived-state memos
+ * need: string/number literals, `<sp>.get('k')`, `<arr>.includes(<x>)`,
+ * module arrow-helper inlining, `<expr> ?? <fallback>`, and string ternaries.
+ * Returns null for anything else so the caller can fall back safely.
+ */
+export declare function lowerCtorExpr(ctx: GoEmitContext, node: ParsedExpr, env: CtorLowerEnv): string | null;
+/**
+ * Lower a JS expression used as a *boolean* condition to a Go bool expression,
+ * or null when it is not provably boolean. Distinct from `lowerCtorExpr`, which
+ * lowers value expressions: a string-valued condition (`sp.get('tag')`) is
+ * truthy in JS but `if "<string>"` does not compile in Go, so anything not
+ * known to yield a Go bool must fall back to null.
+ */
+export declare function lowerCtorCond(ctx: GoEmitContext, node: ParsedExpr, env: CtorLowerEnv): string | null;
+/**
+ * Resolve a string-array expression (a `['a','b']` literal, or a module const
+ * bound to one) to a Go `[]string{…}` literal, or null when it isn't a pure
+ * string-array. Used by `lowerCtorExpr` for `<arr>.includes(<x>)`.
+ */
+export declare function lowerCtorStringArray(ctx: GoEmitContext, node: ParsedExpr): string | null;
+//# sourceMappingURL=ctor-lowering.d.ts.map

package/dist/adapter/memo/ctor-lowering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctor-lowering.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/ctor-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAsBnD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,YAAY,GAChB,MAAM,GAAG,IAAI,CA0Jf;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,YAAY,GAChB,MAAM,GAAG,IAAI,CA2Bf;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAexF"}