@barefootjs/go-template 0.16.0 → 0.17.0

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

@@ -0,0 +1,197 @@
+/**
+ * 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 { foldBlockToExpr } from '@barefootjs/jsx'
+import type { ParsedExpr, ParsedStatement, TypeInfo } from '@barefootjs/jsx'
+
+import type { GoEmitContext } from '../emit-context.ts'
+import type { CtorLowerEnv } from '../lib/types.ts'
+import { capitalizeFieldName } from '../lib/go-naming.ts'
+import { lowerCtorExpr } from './ctor-lowering.ts'
+
+type GuardConstResult = {
+  constName: string
+  constValue: string | undefined
+  constType: TypeInfo | undefined
+  constParsed: ParsedExpr | undefined
+}
+
+const FALSY_INITS = new Set(['null', "''", '""', '0', 'false'])
+
+/** Look the returned const name up as a module-scope constant and package it. */
+function packageModuleConst(ctx: GoEmitContext, name: string): GuardConstResult | null {
+  const constant = ctx.state.localConstants.find(
+    c => c.name === name && c.origin?.scope === 'module',
+  )
+  if (!constant) return null
+  return {
+    constName: constant.name,
+    constValue: constant.value,
+    constType: constant.type ?? undefined,
+    constParsed: constant.parsed,
+  }
+}
+
+/**
+ * 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 function resolveBlockBodyMemoModuleConst(
+  ctx: GoEmitContext,
+  memo: { parsed?: ParsedExpr; parsedBlock?: ParsedStatement[] },
+  signals: { getter: string; initialValue: string }[],
+): GuardConstResult | null {
+  return (
+    fromFoldedConditional(ctx, memo.parsed, signals) ??
+    fromStatementPrefix(ctx, memo.parsedBlock, signals)
+  )
+}
+
+/** Primary: read the folded `!getter() ? MODULE_CONST : <derived>` conditional. */
+function fromFoldedConditional(
+  ctx: GoEmitContext,
+  parsed: ParsedExpr | undefined,
+  signals: { getter: string; initialValue: string }[],
+): GuardConstResult | null {
+  if (!parsed || parsed.kind !== 'conditional') return null
+  const test = parsed.test
+  if (test.kind !== 'unary' || test.op !== '!') return null
+  const guardCall = test.argument
+  if (
+    guardCall.kind !== 'call' ||
+    guardCall.callee.kind !== 'identifier' ||
+    guardCall.args.length !== 0
+  ) {
+    return null
+  }
+  const guardSignal = signals.find(sg => sg.getter === (guardCall.callee as { name: string }).name)
+  if (!guardSignal || !FALSY_INITS.has(guardSignal.initialValue.trim())) return null
+  // `!falsy` is true → the consequent is the returned module const.
+  if (parsed.consequent.kind !== 'identifier') return null
+  return packageModuleConst(ctx, parsed.consequent.name)
+}
+
+/**
+ * Fallback for blocks the fold refused: scan the tolerant statements for the
+ * guard prefix `const k = getter(); if (!k) return MODULE_CONST` (later
+ * statements are ignored — they don't affect the guard-falsy SSR value).
+ */
+function fromStatementPrefix(
+  ctx: GoEmitContext,
+  parsedBlock: ParsedStatement[] | undefined,
+  signals: { getter: string; initialValue: string }[],
+): GuardConstResult | null {
+  if (!parsedBlock) return null
+  const varToSignal = new Map<string, string>()
+  let guardSignalGetter: string | null = null
+  let returnedConst: string | null = null
+
+  for (const s of parsedBlock) {
+    if (s.kind === 'var-decl' && s.init.kind === 'call' && s.init.callee.kind === 'identifier') {
+      const callee = s.init.callee.name
+      if (signals.some(sg => sg.getter === callee)) varToSignal.set(s.name, callee)
+    }
+    if (
+      s.kind === 'if' &&
+      s.condition.kind === 'unary' &&
+      s.condition.op === '!' &&
+      s.condition.argument.kind === 'identifier'
+    ) {
+      const signalGetter = varToSignal.get(s.condition.argument.name)
+      if (!signalGetter) continue
+      for (const rs of s.consequent) {
+        if (rs.kind === 'return' && rs.value.kind === 'identifier') {
+          guardSignalGetter = signalGetter
+          returnedConst = rs.value.name
+        }
+      }
+    }
+    if (guardSignalGetter && returnedConst) break
+  }
+
+  if (!guardSignalGetter || !returnedConst) return null
+  const guardSignal = signals.find(sg => sg.getter === guardSignalGetter)
+  if (!guardSignal || !FALSY_INITS.has(guardSignal.initialValue.trim())) return null
+  return packageModuleConst(ctx, returnedConst)
+}
+
+/**
+ * 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 function computeObjectMemoInitialValue(
+  ctx: GoEmitContext,
+  memo: { parsed?: ParsedExpr; parsedBlock?: ParsedStatement[]; parsedBlockComplete?: boolean },
+): string | null {
+  // Normalize the block to a single object-literal expression (#2040). The
+  // analyzer's fold treats only signal/memo reads as pure, so a
+  // `const sp = searchParams()` (read twice) isn't folded there; redo the fold
+  // here with `searchParams` added to the purity oracle — it is an idempotent
+  // request-query read, so inlining `sp` at each `sp.get('k')` site is sound.
+  // The folded object's values become `searchParams().get('k')` (sp inlined),
+  // lowered by `lowerCtorExpr`. A block that doesn't fold to an object literal
+  // (extra control flow, an impure non-searchParams binding) yields null → the
+  // caller's nil fallback, exactly as the previous statement walk did.
+  let retObj = memo.parsed?.kind === 'object-literal' ? memo.parsed : null
+  if (!retObj) {
+    if (!memo.parsedBlock || !memo.parsedBlockComplete) return null
+    const folded = foldBlockToExpr(memo.parsedBlock, {
+      pureCallNames: ctx.state.searchParamsLocals,
+    })
+    if (!folded.ok || folded.expr.kind !== 'object-literal') return null
+    retObj = folded.expr
+  }
+  if (retObj.properties.length === 0) return null
+
+  // `sp` is inlined to `searchParams()` in the folded values, so no
+  // local→searchParams var env is needed; `lowerCtorExpr` recognises the
+  // `searchParams().get('k')` receiver shape directly.
+  const env: CtorLowerEnv = { searchParamsVars: new Set(), params: new Map() }
+  const entries: string[] = []
+  for (const prop of retObj.properties) {
+    // Bail on a shorthand property (`return { tag }`): its value is a bare
+    // identifier whose name need not match a `.Params.<Field>` accessor.
+    if (prop.shorthand) return null
+    // The key must be identifier- or string-named (a numeric key has no
+    // matching `.Params.<Field>` accessor).
+    if (prop.keyKind !== undefined && prop.keyKind !== 'identifier' && prop.keyKind !== 'string') {
+      return null
+    }
+    const go = lowerCtorExpr(ctx, prop.value, env)
+    if (go === null) return null
+    entries.push(`"${capitalizeFieldName(prop.key)}": ${go}`)
+  }
+  return `map[string]interface{}{\n\t\t${entries.join(',\n\t\t')},\n\t}`
+}

package/src/adapter/memo/template-interp.ts

@@ -0,0 +1,246 @@
+/**
+ * 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'
+import { escapeGoString } from '../lib/go-emit.ts'
+import { capitalizeFieldName } from '../lib/go-naming.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 function computeTemplateLiteralMemoInitialValue(
+  ctx: GoEmitContext,
+  memo: { parsed?: ParsedExpr; parsedBlock?: ParsedStatement[]; parsedBlockComplete?: boolean },
+  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+): string | null {
+  // Resolve the template value (a `template-literal`, or a plain string
+  // `literal` for a no-substitution `` `plain` `` which folds to one) plus any
+  // memo-local `const X = props.Y ?? 'lit'` key bindings.
+  const localKeyBindings = new Map<string, { propName: string; defaultLiteral?: string }>()
+  let templateValue: ParsedExpr | undefined
+  if (memo.parsedBlock) {
+    // Block-bodied arrow (the Toggle `classes` memo): collect leading key
+    // bindings, then resolve against the single returned template literal. Any
+    // statement that isn't a var-decl or the return (an `if`, a loop) is a
+    // shape we don't model — bail.
+    //
+    // `parsedBlock` is tolerant: it OMITS statements it can't represent
+    // (`for`/`while`/`switch`), so an incomplete block could look like just
+    // `var-decl`s + `return`. Bail when it isn't complete.
+    if (!memo.parsedBlockComplete) return null
+    for (const s of memo.parsedBlock) {
+      if (s.kind === 'var-decl') {
+        const binding = parseLocalKeyBinding(ctx, s.init)
+        if (binding) localKeyBindings.set(s.name, binding)
+      } else if (s.kind === 'return') {
+        templateValue = s.value
+      } else {
+        return null
+      }
+    }
+    if (!templateValue) return null
+  } else if (memo.parsed) {
+    templateValue = memo.parsed
+  } else {
+    return null
+  }
+
+  const propNames = new Set(propsParams.map(p => p.name))
+  const escGo = (s: string) => `"${escapeGoString(s)}"`
+
+  // A no-substitution template literal folds to a plain string literal.
+  if (templateValue.kind === 'literal' && templateValue.literalType === 'string') {
+    return escGo(String(templateValue.value))
+  }
+  if (templateValue.kind !== 'template-literal') return null
+
+  const segments: string[] = []
+  for (const part of templateValue.parts) {
+    if (part.type === 'string') {
+      if (part.value) segments.push(escGo(part.value))
+    } else {
+      const resolved = resolveTemplateInterpolation(ctx, part.expr, propNames, localKeyBindings)
+      if (resolved === null) return null
+      segments.push(resolved)
+    }
+  }
+  if (segments.length === 0) return '""'
+  return segments.join(' + ')
+}
+
+/**
+ * Resolve one `${expr}` interpolation of a template-literal memo to a Go string
+ * expression, or null when unsupported. See
+ * `computeTemplateLiteralMemoInitialValue` for the supported shapes.
+ */
+function resolveTemplateInterpolation(
+  ctx: GoEmitContext,
+  node: ParsedExpr,
+  propNames: Set<string>,
+  localKeyBindings: ReadonlyMap<string, { propName: string; defaultLiteral?: string }>,
+): string | null {
+  // Identifier → module string const inline.
+  if (node.kind === 'identifier') {
+    return ctx.resolveModuleStringConst(node.name)
+  }
+
+  // `recordConst[key]` → inline indexed Go map (the Toggle `classes` memo's
+  // `variantClasses[variant]` / `sizeClasses[size]`). A bare-identifier index
+  // parses as `index-access`.
+  if (node.kind === 'index-access') {
+    return recordIndexInterpolationToGo(ctx, node, propNames, localKeyBindings)
+  }
+
+  // `props.X ?? ''` — string-typed prop with an empty-string fallback.
+  if (node.kind === 'logical' && node.op === '??') {
+    const right = node.right
+    const isEmptyStr = right.kind === 'literal' && right.literalType === 'string' && right.value === ''
+    const propName = propsAccessNameFromParsed(ctx, node.left)
+    if (propName && propNames.has(propName) && isEmptyStr) {
+      // Unset string field is "" in Go — same as `?? ''`.
+      return `in.${capitalizeFieldName(propName)}`
+    }
+    return null
+  }
+
+  // Bare `props.X` (string-typed prop).
+  const propName = propsAccessNameFromParsed(ctx, node)
+  if (propName && propNames.has(propName)) {
+    return `in.${capitalizeFieldName(propName)}`
+  }
+  return null
+}
+
+/**
+ * Parse a memo-local `const X = …` initializer (`ParsedExpr`) into a
+ * `Record`-index key binding: `props.Y ?? 'lit'` → `{ propName: 'Y',
+ * defaultLiteral: 'lit' }`, or bare `props.Y` → `{ propName: 'Y' }`. Returns
+ * null for any other shape, so it isn't registered as a key.
+ */
+function parseLocalKeyBinding(
+  ctx: GoEmitContext,
+  node: ParsedExpr,
+): { propName: string; defaultLiteral?: string } | null {
+  if (node.kind === 'logical' && node.op === '??') {
+    const propName = propsAccessNameFromParsed(ctx, node.left)
+    const right = node.right
+    if (propName && right.kind === 'literal' && right.literalType === 'string') {
+      return { propName, defaultLiteral: String(right.value) }
+    }
+    return null
+  }
+  const propName = propsAccessNameFromParsed(ctx, node)
+  if (propName) return { propName }
+  return null
+}
+
+/**
+ * Lower a `recordConst[key]` interpolation to an inline indexed Go map:
+ * `map[string]string{…}[fmt.Sprint(in.Field)]` (or `map[string]any` for mixed
+ * values). `recordConst` is a module-scope `Record<keys, scalar>` object
+ * literal; `key` is a bare prop or a memo-local const bound to `props.X ??
+ * 'default'`, whose `'default'` fallback also maps `""` so an unset prop
+ * renders the default.
+ *
+ * @returns the indexed-map expression, or null for any non-record /
+ *   non-resolvable key
+ */
+function recordIndexInterpolationToGo(
+  ctx: GoEmitContext,
+  node: ParsedExpr & { kind: 'index-access' },
+  propNames: Set<string>,
+  localKeyBindings: ReadonlyMap<string, { propName: string; defaultLiteral?: string }>,
+): string | null {
+  if (node.object.kind !== 'identifier' || node.index.kind !== 'identifier') return null
+  const objName = node.object.name
+  const keyName = node.index.name
+
+  // KEY resolution: a memo-local binding wins (carries the `'default'` key),
+  // else the key must be a bare prop.
+  let indexPropName: string
+  let defaultKey: string | undefined
+  const resolved = localKeyBindings.get(keyName)
+  if (resolved) {
+    indexPropName = resolved.propName
+    defaultKey = resolved.defaultLiteral
+  } else if (propNames.has(keyName)) {
+    indexPropName = keyName
+  } else {
+    return null
+  }
+
+  // IDENT must be a module-scope object-literal const carried as `parsed`.
+  const constInfo = (ctx.state.localConstants ?? []).find(c => c.name === objName && c.isModule)
+  const parsedConst = constInfo?.parsed
+  if (!parsedConst || parsedConst.kind !== 'object-literal') return null
+
+  const entries: { key: string; value: { kind: 'number' | 'string'; text: string } }[] = []
+  for (const prop of parsedConst.properties) {
+    const v = prop.value
+    if (v.kind === 'literal' && v.literalType === 'number') {
+      entries.push({ key: prop.key, value: { kind: 'number', text: v.raw ?? String(v.value) } })
+    } else if (v.kind === 'literal' && v.literalType === 'string') {
+      entries.push({ key: prop.key, value: { kind: 'string', text: String(v.value) } })
+    } else {
+      return null
+    }
+  }
+
+  const goVal = (v: { kind: 'number' | 'string'; text: string }) =>
+    v.kind === 'number' ? v.text : JSON.stringify(v.text)
+  const ents = entries.map(e => `${JSON.stringify(e.key)}: ${goVal(e.value)}`)
+  if (defaultKey !== undefined) {
+    const def = entries.find(e => e.key === defaultKey)
+    if (def) ents.unshift(`"": ${goVal(def.value)}`)
+  }
+  const allString = entries.every(e => e.value.kind === 'string')
+  const mapType = allString ? 'map[string]string' : 'map[string]any'
+  ctx.state.usesFmt = true
+  return `${mapType}{${ents.join(', ')}}[fmt.Sprint(in.${capitalizeFieldName(indexPropName)})]`
+}
+
+/**
+ * `ParsedExpr` counterpart of `propsAccessName`: if `node` is a
+ * `<propsObjectName>.<name>` member access, return `<name>`, else null.
+ */
+function propsAccessNameFromParsed(ctx: GoEmitContext, node: ParsedExpr): string | null {
+  if (node.kind !== 'member' || node.computed) return null
+  if (node.object.kind !== 'identifier') return null
+  if (!ctx.state.propsObjectName || node.object.name !== ctx.state.propsObjectName) return null
+  return node.property
+}
+
+/**
+ * If `node` is a `<propsObjectName>.<name>` access, return `<name>`, else
+ * null. Used to recognize props-object reads inside memo interpolations.
+ */
+export function propsAccessName(ctx: GoEmitContext, node: ts.Expression): string | null {
+  if (!ts.isPropertyAccessExpression(node)) return null
+  if (!ts.isIdentifier(node.expression)) return null
+  if (!ctx.state.propsObjectName || node.expression.text !== ctx.state.propsObjectName) return null
+  return node.name.text
+}

package/src/adapter/props/prop-types.ts

@@ -0,0 +1,84 @@
+/**
+ * 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'
+import { typeInfoToGo } from '../type/type-codegen.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 function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map<string, string> {
+  const overrides = new Map<string, string>()
+  for (const signal of ir.metadata.signals) {
+    const propNames = [signal.initialValue]
+    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue)
+    if (extracted) propNames.push(extracted)
+
+    for (const propName of propNames) {
+      const param = ir.metadata.propsParams.find(p => p.name === propName)
+      if (!param) continue
+      const propGoType = typeInfoToGo(ctx, param.type, param.defaultValue)
+      if (propGoType.includes('interface{}')) {
+        const signalGoType = typeInfoToGo(ctx, signal.type, signal.initialValue)
+        if (!signalGoType.includes('interface{}')) {
+          overrides.set(propName, signalGoType)
+        }
+      }
+    }
+  }
+  return overrides
+}
+
+/**
+ * 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 function resolvePropGoType(
+  ctx: GoEmitContext,
+  param: IRMetadata['propsParams'][number],
+  propTypeOverrides: Map<string, string>,
+): string {
+  const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue)
+  // An OPTIONAL prop typed as a named struct (`opts?: EmblaOptionsType`) lowers
+  // to `map[string]interface{}`, not the value struct: a value struct is always
+  // truthy in Go templates (so a `{{if .Opts}}`-guarded attribute could never be
+  // omitted), whereas a nil/empty map is falsy and round-trips through `bf_json`
+  // with only the supplied keys — matching JS `JSON.stringify` of a partial
+  // object instead of a zero-filled struct.
+  // Gate on `localStructFields` (an actual generated struct), NOT
+  // `localTypeNames` — the latter also covers string-union aliases
+  // (`placement?: 'top' | 'right' | …`), which must stay their scalar Go type.
+  if (param.optional && ctx.state.localStructFields.has(base)) {
+    return 'map[string]interface{}'
+  }
+  return base
+}
+
+/**
+ * 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 function collectNillablePropNames(ctx: GoEmitContext, ir: ComponentIR): Set<string> {
+  const propTypeOverrides = buildPropTypeOverrides(ctx, ir)
+  const nillable = new Set<string>()
+  for (const param of ir.metadata.propsParams) {
+    if (resolvePropGoType(ctx, param, propTypeOverrides) === 'interface{}') {
+      nillable.add(param.name)
+    }
+  }
+  return nillable
+}