@barefootjs/go-template 0.16.0 → 0.17.0

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

@@ -0,0 +1,162 @@
+/**
+ * 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'
+import { capitalizeFieldName } from '../lib/go-naming.ts'
+import { parsedLiteralToGo } from './parsed-literal-to-go.ts'
+
+/** Default for `getSignalInitialValueAsGo`'s optional fallback-var map. */
+const EMPTY_PROP_FALLBACK_VARS: ReadonlyMap<string, PropFallbackVar> = new Map()
+
+/**
+ * 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 function convertInitialValue(
+  ctx: GoEmitContext,
+  value: string,
+  typeInfo: TypeInfo,
+  propsParams?: { name: string }[],
+  preParsed?: ParsedExpr,
+): string {
+  if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
+    if (propsParams?.some(p => p.name === value)) {
+      return `in.${capitalizeFieldName(value)}`
+    }
+  }
+
+  const propName = ctx.extractPropNameFromInitialValue(value)
+  if (propName && propsParams?.some(p => p.name === propName)) {
+    return `in.${capitalizeFieldName(propName)}`
+  }
+
+  if (typeInfo.kind === 'primitive') {
+    if (typeInfo.primitive === 'boolean') {
+      return value === 'true' ? 'true' : 'false'
+    }
+    if (typeInfo.primitive === 'number') {
+      if (/^\d+$/.test(value)) return value
+      if (/^\d+\.\d+$/.test(value)) return value
+      return '0'
+    }
+    if (typeInfo.primitive === 'string') {
+      if (value.startsWith("'") || value.endsWith("'")) {
+        return value.replace(/'/g, '"')
+      }
+      if (value.startsWith('"') && value.endsWith('"')) {
+        return value
+      }
+      return '""'
+    }
+  }
+
+  if (typeInfo.kind === 'array') {
+    return jsLiteralToGo(ctx, typeInfo, preParsed) ?? 'nil'
+  }
+
+  // A string type-alias keeps its string value instead of falling to nil.
+  if (typeInfo.kind === 'interface' && typeInfo.raw) {
+    const aliasBase = ctx.state.localTypeAliases.get(typeInfo.raw)
+    if (aliasBase === 'string') {
+      if (value.startsWith("'") || value.startsWith('"')) {
+        return value.replace(/'/g, '"')
+      }
+      return '""'
+    }
+  }
+
+  return 'nil'
+}
+
+/**
+ * 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 function jsLiteralToGo(
+  ctx: GoEmitContext,
+  typeInfo: TypeInfo,
+  preParsed?: ParsedExpr,
+): string | null {
+  if (preParsed) {
+    const structured = parsedLiteralToGo(ctx, preParsed, typeInfo)
+    if (structured !== null) return structured
+  }
+  return 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 function objectLiteralToGoMap(ctx: GoEmitContext, expr: ParsedExpr): string | null {
+  if (expr.kind !== 'object-literal') return null
+  const entries: string[] = []
+  for (const prop of expr.properties) {
+    if (prop.shorthand) return null
+    const val = parsedLiteralToGo(ctx, prop.value)
+    if (val === null) return null
+    entries.push(`${JSON.stringify(prop.key)}: ${val}`)
+  }
+  if (entries.length === 0) return null
+  return `map[string]interface{}{${entries.join(', ')}}`
+}
+
+/**
+ * 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 function getSignalInitialValueAsGo(
+  ctx: GoEmitContext,
+  initialValue: string,
+  propsParams: { name: string }[],
+  propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
+): string {
+  if (propsParams.some(p => p.name === initialValue)) {
+    const hoisted = propFallbackVars.get(initialValue)
+    if (hoisted) return hoisted.varName
+    return `in.${capitalizeFieldName(initialValue)}`
+  }
+
+  const propName = ctx.extractPropNameFromInitialValue(initialValue)
+  if (propName && propsParams.some(p => p.name === propName)) {
+    const hoisted = propFallbackVars.get(propName)
+    if (hoisted) return hoisted.varName
+    return `in.${capitalizeFieldName(propName)}`
+  }
+
+  // single quotes are normalized to Go double quotes
+  if (/^-?\d+$/.test(initialValue)) {
+    return initialValue
+  }
+  if (/^-?\d+\.\d+$/.test(initialValue)) {
+    return initialValue
+  }
+  if (initialValue === 'true' || initialValue === 'false') {
+    return initialValue
+  }
+  if ((initialValue.startsWith("'") && initialValue.endsWith("'")) ||
+      (initialValue.startsWith('"') && initialValue.endsWith('"'))) {
+    return initialValue.replace(/'/g, '"')
+  }
+
+  return '0'
+}

package/src/test-render.ts

@@ -9,19 +9,7 @@ import { compileJSX } from '@barefootjs/jsx'
 import type { TemplateAdapter, ComponentIR } from '@barefootjs/jsx'
 import { GoTemplateAdapter } from './adapter/go-template-adapter.ts'
 import { deduplicateGoTypes } from './build.ts'
-
-/**
- * Capitalize a JSON key to its Go struct field name using the same
- * initialism rules as the adapter (`capitalizeFieldName`): a whole-word Go
- * initialism uppercases entirely (`id` → `ID`), otherwise just the first
- * letter. Keeps harness-emitted struct literals (`ItemInput{ID: …}`) matching
- * the generated exported field names. (#1297)
- */
-function capitalizeGoField(name: string): string {
-  if (!name) return name
-  if (GoTemplateAdapter.GO_INITIALISMS.has(name.toLowerCase())) return name.toUpperCase()
-  return name.charAt(0).toUpperCase() + name.slice(1)
-}
+import { capitalizeFieldName } from './adapter/lib/go-naming.ts'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -703,7 +691,7 @@ function goTypedSliceLiteralFromArray(arr: unknown[], elemType: string): string
 function goStructLiteral(obj: Record<string, unknown>, typeName: string): string {
   const fields: string[] = []
   for (const [k, v] of Object.entries(obj)) {
-    const goField = capitalizeGoField(k)
+    const goField = capitalizeFieldName(k)
     if (typeof v === 'string') fields.push(`${goField}: "${v.replace(/"/g, '\\"')}"`)
     else if (typeof v === 'number' || typeof v === 'boolean') fields.push(`${goField}: ${v}`)
     else if (v === null) fields.push(`${goField}: nil`)