@barefootjs/go-template 0.16.0 → 0.17.0

package/dist/adapter/memo/memo-compute.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Memo initial-value computation — lower a memo's computation to its SSR initial
+ * value as a Go expression.
+ *
+ * Free functions over a {@link GoEmitContext}. `computeMemoInitialValue` is the
+ * typed-field entry (zero-value defaulting); `computeMemoInitialValueOrNull` is
+ * the pattern-matching core dispatching over template-literal, parsed-body,
+ * comparison-ternary, block-body and object memo shapes.
+ */
+import type { ParsedExpr, ParsedStatement, TypeInfo } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+import type { PropFallbackVar } from '../lib/types.ts';
+/**
+ * Compute a memo's SSR initial value as a Go expression — e.g.
+ * `() => count() * 2` → `in.Initial * 2`, `() => props.value * 10` →
+ * `in.Value * 10`. Unresolved computations default to the memo's Go zero value.
+ *
+ * @param propFallbackVars when a hoisted fallback var exists for a referenced
+ *   prop, it is substituted for `in.FieldName` so the memo inherits the
+ *   signal-time `??` fallback
+ * @param goType Go type of the memo field, used to pick the zero-value fallback
+ */
+export declare function computeMemoInitialValue(ctx: GoEmitContext, memo: {
+    name: string;
+    computation: string;
+    deps: string[];
+    parsed?: ParsedExpr;
+}, signals: {
+    getter: string;
+    initialValue: string;
+}[], propsParams: {
+    name: string;
+    type?: TypeInfo;
+    defaultValue?: string;
+}[], propFallbackVars?: ReadonlyMap<string, PropFallbackVar>, goType?: string): string;
+/**
+ * Structural matcher for the common expression-bodied memo shapes, driven by
+ * the analyzer-attached `MemoInfo.parsed` (the memo arrow's body): `getter() ===
+ * 'lit'`, `props.X ?? false`, `cond() ? A : B`, `<getter()|props.X|var> <*+-/>
+ * <int>`, and bare `getter()` / `props.X` / `var`.
+ *
+ * @returns the Go SSR value, or null when the body is none of these (the caller
+ *   then falls through to comparison-ternary / block-body / object-memo handling)
+ */
+export declare function memoInitialFromParsedBody(ctx: GoEmitContext, body: ParsedExpr, signals: {
+    getter: string;
+    initialValue: string;
+}[], propsParams: {
+    name: string;
+    type?: TypeInfo;
+    defaultValue?: string;
+}[], propFallbackVars: ReadonlyMap<string, PropFallbackVar>): string | null;
+/**
+ * Pattern-matching core of `computeMemoInitialValue`.
+ *
+ * @returns the memo's SSR initial value as a Go expression, or `null` when no
+ *   pattern applies. Callers with a typed field to fill use the
+ *   zero-value-defaulting wrapper above; callers that can OMIT the field (a
+ *   child-instance prop init, where Go's zero values then apply with the right
+ *   type) use this directly.
+ */
+export declare function computeMemoInitialValueOrNull(ctx: GoEmitContext, memo: {
+    name: string;
+    computation: string;
+    deps: string[];
+    parsed?: ParsedExpr;
+    parsedBlock?: ParsedStatement[];
+    parsedBlockComplete?: boolean;
+}, signals: {
+    getter: string;
+    initialValue: string;
+}[], propsParams: {
+    name: string;
+    type?: TypeInfo;
+    defaultValue?: string;
+}[], propFallbackVars?: ReadonlyMap<string, PropFallbackVar>): string | null;
+/**
+ * Resolve a signal/memo getter NAME to a Go value expression, for use as the
+ * condition operand of another memo's ternary. Handles a plain signal, a
+ * prop-shadow memo `() => props.X ?? 'lit'` (→ a nil/empty-tolerant field
+ * read), else recurses.
+ *
+ * @returns the Go expression, or null when the shape isn't representable
+ */
+export declare function resolveGetterValueAsGo(ctx: GoEmitContext, name: string, signals: {
+    getter: string;
+    initialValue: string;
+}[], propsParams: {
+    name: string;
+    type?: TypeInfo;
+    defaultValue?: string;
+}[], propFallbackVars: ReadonlyMap<string, PropFallbackVar>): string | null;
+/**
+ * Resolve a string-ternary memo whose condition is a literal comparison —
+ * `() => <operand> === 'lit' ? A : B` (or `!==`) — to a Go runtime conditional.
+ * Branches must be string literals/module-string-consts; the operand resolves
+ * via `resolveComparisonOperandGo`.
+ *
+ * @returns the Go conditional, or null when the shape isn't supported
+ */
+export declare function computeComparisonTernaryGo(ctx: GoEmitContext, parsed: ParsedExpr | undefined, signals: {
+    getter: string;
+    initialValue: string;
+}[], propsParams: {
+    name: string;
+    type?: TypeInfo;
+    defaultValue?: string;
+}[], propFallbackVars: ReadonlyMap<string, PropFallbackVar>): string | null;
+/**
+ * Resolve the left operand of a string-ternary memo's comparison condition to a
+ * Go expression: a zero-arg getter call (a signal/prop-shadow memo), an inline
+ * `props.X ?? 'def'` (folds the default), or a bare `props.X`.
+ *
+ * @returns the Go expression, or null for anything else
+ */
+export declare function resolveComparisonOperandGo(ctx: GoEmitContext, node: ParsedExpr, signals: {
+    getter: string;
+    initialValue: string;
+}[], propsParams: {
+    name: string;
+    type?: TypeInfo;
+    defaultValue?: string;
+}[], propFallbackVars: ReadonlyMap<string, PropFallbackVar>): string | null;
+//# sourceMappingURL=memo-compute.d.ts.map

package/dist/adapter/memo/memo-compute.d.ts.map

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

package/dist/adapter/memo/memo-type.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Memo type inference predicates.
+ *
+ * Pure free functions over a {@link GoEmitContext} that classify a memo's
+ * computation so `inferMemoType` can pick the right Go field type (and thus the
+ * right SSR zero value).
+ */
+import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+/**
+ * Heuristic: does this memo evaluate to a boolean? True when its computation is
+ * a comparison (`!==`/`===`/`!=`/`==`), a negation (`!x`), or a ternary whose
+ * branches are all boolean signals/props. Used to pick `bool` (zero value
+ * `false`) over the int `0` default for the SSR initial value.
+ */
+export declare function isBooleanMemo(ctx: GoEmitContext, memo: {
+    computation: string;
+    deps: string[];
+    parsed?: ParsedExpr;
+}, signals: {
+    getter: string;
+    initialValue: string;
+    type: TypeInfo;
+}[], propsParamMap: Map<string, {
+    name: string;
+    type: TypeInfo;
+    defaultValue?: string;
+}>): boolean;
+/**
+ * Does this memo's body resolve to a ternary whose BOTH branches are
+ * string-valued — e.g. `() => orientation() === 'vertical' ? 'flex-col' :
+ * 'flex'`? Such a memo is a string, not a bool, even though its condition
+ * contains `===`. Since #2040 a block-bodied memo can also carry `parsed` (a
+ * value `if` / early-return folds to a ternary), so this now applies to those
+ * too — the inferred field type follows the folded shape, not the syntax.
+ */
+export declare function isStringTernaryMemo(ctx: GoEmitContext, parsed: ParsedExpr | undefined): boolean;
+//# sourceMappingURL=memo-type.d.ts.map

package/dist/adapter/memo/memo-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo-type.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/memo-type.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAGvD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAAE,EAClE,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,EAAE,EACnE,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAClF,OAAO,CA8BT;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAS/F"}

package/dist/adapter/memo/memo-value.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Memo value computation for block-body / object-returning memos.
+ *
+ * Free functions over a {@link GoEmitContext}:
+ *   - `resolveBlockBodyMemoModuleConst` recognises a guard-and-return-module-
+ *     const memo and reports the constant, reading `state.localConstants`.
+ *   - `computeObjectMemoInitialValue` lowers a `searchParams()`-derived
+ *     object-returning memo to a Go `map[string]interface{}` literal, reading
+ *     the analyzer-carried `parsedBlock` and `state.searchParamsLocals` and
+ *     delegating value lowering to `lowerCtorExpr`.
+ */
+import type { ParsedExpr, ParsedStatement, TypeInfo } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+type GuardConstResult = {
+    constName: string;
+    constValue: string | undefined;
+    constType: TypeInfo | undefined;
+    constParsed: ParsedExpr | undefined;
+};
+/**
+ * Recognise a block-body memo whose SSR path returns a module-const array when
+ * the guard signal starts falsy:
+ *   `() => { const k = getter(); if (!k) return MODULE_CONST; … }`
+ *
+ * Primary path: the block is normalized to a single expression upstream (#2040,
+ * `foldBlockToExpr` in the analyzer), so this reads the folded `MemoInfo.parsed`
+ * conditional `!getter() ? MODULE_CONST : <derived>`. When the guard signal's
+ * initial value is falsy, `!guard` is `true`, so the `consequent` is the const
+ * rendered at SSR.
+ *
+ * Fallback path: a block the fold REFUSES (e.g. an impure local binding that
+ * isn't used exactly once per path sits alongside the guard) leaves
+ * `MemoInfo.parsed` unset, but the guard prefix is still present in the tolerant
+ * `MemoInfo.parsedBlock`. Scan that prefix so the SSR const bake matches `main`
+ * exactly — the bake depends only on the guard, not on the unfoldable tail.
+ *
+ * @returns the constant's name, value, inferred type and parsed tree, or null
+ */
+export declare function resolveBlockBodyMemoModuleConst(ctx: GoEmitContext, memo: {
+    parsed?: ParsedExpr;
+    parsedBlock?: ParsedStatement[];
+}, signals: {
+    getter: string;
+    initialValue: string;
+}[]): GuardConstResult | null;
+/**
+ * Compute the SSR value of an object-returning block-body memo derived from
+ * `searchParams()`:
+ *   () => { const sp = searchParams(); return { sort: asSortKey(sp.get('sort')),
+ *                                               tag: sp.get('tag') ?? '' } }
+ * Emits a Go `map[string]interface{}{ "Sort": …, "Tag": … }` whose values are
+ * lowered from the request query (see `lowerCtorExpr`). Keys are capitalized to
+ * match the template's `.Params.<Field>` map access.
+ *
+ * @returns the Go map literal, or null for any shape the lowerer can't
+ *   represent (→ nil-map fallback)
+ */
+export declare function computeObjectMemoInitialValue(ctx: GoEmitContext, memo: {
+    parsed?: ParsedExpr;
+    parsedBlock?: ParsedStatement[];
+    parsedBlockComplete?: boolean;
+}): string | null;
+export {};
+//# sourceMappingURL=memo-value.d.ts.map

package/dist/adapter/memo/memo-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo-value.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/memo-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAKvD,KAAK,gBAAgB,GAAG;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC/B,WAAW,EAAE,UAAU,GAAG,SAAS,CAAA;CACpC,CAAA;AAkBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,UAAU,CAAC;IAAC,WAAW,CAAC,EAAE,eAAe,EAAE,CAAA;CAAE,EAC9D,OAAO,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,EAAE,GAClD,gBAAgB,GAAG,IAAI,CAKzB;AAsED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,UAAU,CAAC;IAAC,WAAW,CAAC,EAAE,eAAe,EAAE,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,GAC5F,MAAM,GAAG,IAAI,CAwCf"}

package/dist/adapter/memo/template-interp.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Template-literal memo lowering.
+ *
+ * Free functions over a {@link GoEmitContext} that compute the SSR initial
+ * value of a template-literal memo (`() => `${a} ${props.x ?? ''} grid``) as a
+ * Go `string` expression. Each quasi becomes a Go string literal; each
+ * interpolation resolves to a module string const, a `Record`-index access, or
+ * a `props.<name>` field read. Sets `state.usesFmt` when a `Record`-index
+ * interpolation emits `fmt.Sprint`.
+ */
+import ts from 'typescript';
+import type { ParsedExpr, ParsedStatement, TypeInfo } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+/**
+ * Compute the SSR initial value of a template-literal memo as a Go `string`
+ * expression, e.g. `() => `${a} ${props.className ?? ''} grid``.
+ *
+ * Each quasi becomes a Go string literal; each interpolation is resolved:
+ *   - an identifier naming a module string const → its inlined literal (covers
+ *     pure-string and `[...].join(' ')` consts);
+ *   - `props.<name> ?? '<fallback>'` or bare `props.<name>` → `in.<Field>` when
+ *     `<name>` is a known string-typed prop param (the `?? ''` fallback maps to
+ *     Go's zero value for an unset string field).
+ *
+ * @returns the `"a" + in.Field + " grid..."` concatenation, or null when the
+ *   computation isn't a single template literal or any interpolation isn't
+ *   representable
+ */
+export declare function computeTemplateLiteralMemoInitialValue(ctx: GoEmitContext, memo: {
+    parsed?: ParsedExpr;
+    parsedBlock?: ParsedStatement[];
+    parsedBlockComplete?: boolean;
+}, propsParams: {
+    name: string;
+    type?: TypeInfo;
+    defaultValue?: string;
+}[]): string | null;
+/**
+ * If `node` is a `<propsObjectName>.<name>` access, return `<name>`, else
+ * null. Used to recognize props-object reads inside memo interpolations.
+ */
+export declare function propsAccessName(ctx: GoEmitContext, node: ts.Expression): string | null;
+//# sourceMappingURL=template-interp.d.ts.map

package/dist/adapter/memo/template-interp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-interp.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/template-interp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAIvD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sCAAsC,CACpD,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,UAAU,CAAC;IAAC,WAAW,CAAC,EAAE,eAAe,EAAE,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,EAC7F,WAAW,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GACtE,MAAM,GAAG,IAAI,CAsDf;AAgJD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,GAAG,IAAI,CAKtF"}

package/dist/adapter/props/prop-types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Prop-type resolution: decide each prop's Go struct-field type.
+ *
+ * Free functions over a {@link GoEmitContext}, shared by the Input/Props struct
+ * generators and the nillable-field set so they can't drift.
+ */
+import type { ComponentIR, IRMetadata } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+/**
+ * Build a map from prop name to a better Go type inferred from signals. When a
+ * signal is initialized from a prop (`createSignal(props.initial ?? 0)`), the
+ * signal's type annotation may be more specific than the prop's `TypeInfo`. Only
+ * generic prop types (containing `interface{}`) are overridden.
+ */
+export declare function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map<string, string>;
+/**
+ * Resolve a prop param's Go struct-field type using the SAME logic
+ * `generatePropsStruct` / `generateInputStruct` use: a `propTypeOverrides` entry
+ * wins, otherwise `typeInfoToGo(param.type, param.defaultValue)`. Factored out so
+ * the nillable-field set (`collectNillablePropNames`) can't drift from the
+ * emitted field types.
+ */
+export declare function resolvePropGoType(ctx: GoEmitContext, param: IRMetadata['propsParams'][number], propTypeOverrides: Map<string, string>): string;
+/**
+ * Build the set of prop NAMES whose resolved Go field type is exactly
+ * `interface{}` (nillable, for Hono-style attribute omission). Uses the same
+ * `propTypeOverrides` + `resolvePropGoType` pipeline as the struct generators.
+ * Concrete (`string`/`int`/`bool`/`[]T`/struct) types are excluded.
+ */
+export declare function collectNillablePropNames(ctx: GoEmitContext, ir: ComponentIR): Set<string>;
+//# sourceMappingURL=prop-types.d.ts.map

package/dist/adapter/props/prop-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-types.d.ts","sourceRoot":"","sources":["../../../src/adapter/props/prop-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAGvD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,aAAa,EAAE,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAoB/F;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,EACxC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACrC,MAAM,CAeR;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,aAAa,EAAE,EAAE,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CASzF"}

package/dist/adapter/spread/spread-codegen.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Spread-bag codegen: lower JSX `{...spread}` attributes to Go.
+ *
+ * Free functions over a {@link GoEmitContext}. Two entry points:
+ *   - `collectSpreadSlots` walks the IR (stopping at loop bodies) to gather the
+ *     `SpreadSlotInfo` entries plumbed onto the Input/Props structs.
+ *   - `buildSpreadInitializer` builds the Go expression for a spread bag's
+ *     initial value placed inside `NewXxxProps`: signal-getter object literals,
+ *     destructured / SolidJS-style / rest props, and conditional inline-object
+ *     spreads.
+ */
+import type { ComponentIR, IRNode, ParsedExpr } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+import type { SpreadSlotInfo } from '../lib/types.ts';
+/**
+ * Walk the IR (elements, fragments, conditionals, providers, async, components)
+ * but stop at loop bodies. Each `'spread'` attr value with a `slotId` becomes
+ * one `SpreadSlotInfo` entry.
+ */
+export declare function collectSpreadSlots(ctx: GoEmitContext, node: IRNode): SpreadSlotInfo[];
+/**
+ * Build a Go expression for a JSX spread bag's initial value, placed inside
+ * `NewXxxProps`'s return literal.
+ *
+ * Supported shapes:
+ *   - Signal-getter call (`attrs()`): emit the signal's object literal as a Go
+ *     `map[string]any{...}`.
+ *   - Bare identifier matching a destructured `propsParam`: emit `in.<Field>`.
+ *   - Bare identifier matching `propsObjectName` (SolidJS-style `props`):
+ *     enumerate `propsParams` into an inline `map[string]any{...}` (each Input
+ *     field becomes a bag key).
+ *   - Bare identifier matching `restPropsName` (destructured rest): emit
+ *     `in.<Field>` against the `map[string]any` Input field added for
+ *     `input-bag` slots; the caller populates the open-ended rest values.
+ *
+ * @returns `null` for unsupported shapes so the caller can raise a narrowed
+ *   BF101 with the offending expression.
+ */
+export declare function buildSpreadInitializer(ctx: GoEmitContext, spreadExpr: string, ir: ComponentIR, parsed?: ParsedExpr): string | null;
+//# sourceMappingURL=spread-codegen.d.ts.map

package/dist/adapter/spread/spread-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spread-codegen.d.ts","sourceRoot":"","sources":["../../../src/adapter/spread/spread-codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EACV,WAAW,EACX,MAAM,EAQN,UAAU,EACX,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAGrD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAIrF;AAuID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,aAAa,EAClB,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,WAAW,EACf,MAAM,CAAC,EAAE,UAAU,GAClB,MAAM,GAAG,IAAI,CA0Ef"}

package/dist/adapter/type/type-codegen.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type codegen: render TypeScript types as Go type strings.
+ *
+ * Free functions over a {@link GoEmitContext}. They resolve a prop/signal/const's
+ * type (`TypeInfo`, a raw type string, or — as a last resort — an inferred shape
+ * from a literal value) into the Go type used for its struct field. They read
+ * only `state.localTypeNames`; `inferTypeFromValue` is fully pure.
+ */
+import type { TypeInfo } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+/**
+ * Convert a `TypeInfo` to a Go type string.
+ *
+ * @param defaultValue used to infer the type when `typeInfo.kind` is `unknown`
+ * @returns the Go type, falling back to `interface{}` when unresolvable
+ */
+export declare function typeInfoToGo(ctx: GoEmitContext, typeInfo: TypeInfo, defaultValue?: string): string;
+/**
+ * Convert a raw TypeScript type string to a Go type string. Handles primitives,
+ * `T[]` / `Array<T>` arrays, and known local types; else `interface{}`.
+ */
+export declare function tsTypeStringToGo(ctx: GoEmitContext, tsType: string): string;
+/** Infer a Go type from a JS value literal; `interface{}` when unrecognized. */
+export declare function inferTypeFromValue(value: string): string;
+//# sourceMappingURL=type-codegen.d.ts.map

package/dist/adapter/type/type-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-codegen.d.ts","sourceRoot":"","sources":["../../../src/adapter/type/type-codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,aAAa,EAClB,QAAQ,EAAE,QAAQ,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAsCR;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAa3E;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWxD"}

package/dist/adapter/value/parsed-literal-to-go.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Lower a structured literal `ParsedExpr` (carried on the IR) to a Go literal,
+ * for baking a signal's inline initial value into the SSR data context.
+ *
+ * Covers scalar literals, a unary-minus number, arrays of those, and object
+ * literals baked against a concrete local struct.
+ *
+ * Contract is **null-means-defer**: returns null for anything not reproduced
+ * exactly — an object whose target type isn't a known struct, a key the struct
+ * doesn't declare, a nested object/array property value, an empty array, an
+ * identifier/call, or a numeric literal missing its `raw` token. The caller
+ * then keeps `nil`.
+ */
+import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+export declare function parsedLiteralToGo(ctx: GoEmitContext, expr: ParsedExpr, typeInfo?: TypeInfo): string | null;
+//# sourceMappingURL=parsed-literal-to-go.d.ts.map

package/dist/adapter/value/parsed-literal-to-go.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsed-literal-to-go.d.ts","sourceRoot":"","sources":["../../../src/adapter/value/parsed-literal-to-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAGvD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,aAAa,EAClB,IAAI,EAAE,UAAU,EAChB,QAAQ,CAAC,EAAE,QAAQ,GAClB,MAAM,GAAG,IAAI,CAsEf"}

package/dist/adapter/value/value-lowering.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Value lowering: convert a JS signal/const initial value into a Go literal for
+ * the SSR data context — scalars, prop references, and fully-literal
+ * arrays/objects — falling back to `nil`/`0` for anything not reducible to a
+ * literal. Pure free functions over a {@link GoEmitContext}.
+ */
+import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx';
+import type { GoEmitContext } from '../emit-context.ts';
+import type { PropFallbackVar } from '../lib/types.ts';
+/**
+ * Lower a signal/const initial value to its Go SSR literal: a prop reference
+ * becomes `in.<Field>`, a non-literal falls back to the type's zero value.
+ */
+export declare function convertInitialValue(ctx: GoEmitContext, value: string, typeInfo: TypeInfo, propsParams?: {
+    name: string;
+}[], preParsed?: ParsedExpr): string;
+/**
+ * Lower a fully-literal value — from the analyzer's carried `ParsedExpr` tree —
+ * to a Go literal typed as `typeInfo`:
+ *
+ *   `["x", "y"]`    (string[])  → `[]string{"x", "y"}`
+ *   `["x", "y"]`    (unknown[]) → `[]interface{}{"x", "y"}`
+ *   `[{ id: "a" }]` (Item[])    → `[]Item{Item{ID: "a"}}`
+ *
+ * Returns null (caller keeps `nil`) for a non-literal, or a shape that can't be
+ * expressed in the target type (e.g. an object in a `[]interface{}`, unreachable
+ * via the template's struct-field access).
+ */
+export declare function jsLiteralToGo(ctx: GoEmitContext, typeInfo: TypeInfo, preParsed?: ParsedExpr): string | null;
+/**
+ * Bake a flat object literal (`{ align: 'start' }`) into a Go
+ * `map[string]interface{}` keyed by SOURCE property names, so it round-trips
+ * through `bf_json` like `JSON.stringify` (only the supplied keys, no zero-filled
+ * struct fields). Used for an inline object passed to a child's optional object
+ * prop. Returns null for a non-object / shorthand / nested / empty object.
+ */
+export declare function objectLiteralToGoMap(ctx: GoEmitContext, expr: ParsedExpr): string | null;
+/**
+ * Get a signal's initial value as Go code — a literal, or a props reference
+ * (`in.<Field>`, or the hoisted fallback var when `props.X ?? N` has one).
+ * Unrecognized values default to `0`.
+ */
+export declare function getSignalInitialValueAsGo(ctx: GoEmitContext, initialValue: string, propsParams: {
+    name: string;
+}[], propFallbackVars?: ReadonlyMap<string, PropFallbackVar>): string;
+//# sourceMappingURL=value-lowering.d.ts.map

package/dist/adapter/value/value-lowering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-lowering.d.ts","sourceRoot":"","sources":["../../../src/adapter/value/value-lowering.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAOtD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,EAClB,WAAW,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,EAChC,SAAS,CAAC,EAAE,UAAU,GACrB,MAAM,CAgDR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,aAAa,EAClB,QAAQ,EAAE,QAAQ,EAClB,SAAS,CAAC,EAAE,UAAU,GACrB,MAAM,GAAG,IAAI,CAMf;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAWxF;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,aAAa,EAClB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,EAC/B,gBAAgB,GAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAA4B,GAChF,MAAM,CA8BR"}