@barefootjs/go-template 0.16.0 → 0.17.1

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'
 
@@ -627,13 +615,23 @@ function buildGoPropsInit(
       // a bare `[]any{…}` would fail to compile against the typed field.
       // Fall back to `[]any` when the field type is `[]any` / unknown.
       const elemType = goSliceElemType(goTypes, componentName, goField)
-      lines.push(
-        `\t\t${goField}: ${
-          elemType
-            ? goTypedSliceLiteralFromArray(value, elemType)
-            : goArrayLiteralFromArray(value)
-        },`,
-      )
+      let sliceLiteral: string
+      if (elemType && elemType.startsWith('map[')) {
+        // An untyped object-array Input field (an inline prop object type
+        // that didn't synthesize a named struct, e.g. `items: { title:
+        // string; tags: string[] }[]` — `typeInfoToGo`'s 'object' case,
+        // type-codegen.ts) resolves to `[]map[string]interface{}`, not a
+        // named struct. `goTypedSliceLiteralFromArray`'s `goStructLiteral`
+        // emits bare `Field: value` entries, which is struct-literal syntax
+        // and doesn't compile as a map literal's keys — route these through
+        // the map-literal builder instead (#2075, search-params-derived-filter).
+        sliceLiteral = goTypedMapSliceLiteralFromArray(value, elemType)
+      } else if (elemType) {
+        sliceLiteral = goTypedSliceLiteralFromArray(value, elemType)
+      } else {
+        sliceLiteral = goArrayLiteralFromArray(value)
+      }
+      lines.push(`\t\t${goField}: ${sliceLiteral},`)
     } else if (value && typeof value === 'object') {
       // Plain object → Go `map[string]any` literal (#1407 follow-up).
       // Used by `jsx-spread-rest-prop` to populate the input-bag
@@ -670,7 +668,11 @@ function goSliceElemType(
     new RegExp(`type ${componentName}Input struct \\{([\\s\\S]*?)\\n\\}`),
   )
   if (!struct) return null
-  const field = struct[1].match(new RegExp(`\\n\\s*${goField}\\s+\\[\\]([\\w.]+)`))
+  // The element-type token can carry brackets/braces of its own (a map type
+  // like `map[string]interface{}`), not just word chars — broadened so the
+  // capture doesn't truncate at the first `[`. The token has no internal
+  // whitespace, so it still stops cleanly before a trailing `// comment`.
+  const field = struct[1].match(new RegExp(`\\n\\s*${goField}\\s+\\[\\]([\\w.[\\]{}]+)`))
   if (!field) return null
   const elem = field[1]
   if (elem === 'any' || elem === 'interface{}') return null
@@ -695,6 +697,30 @@ function goTypedSliceLiteralFromArray(arr: unknown[], elemType: string): string
   return `[]${elemType}{${entries.join(', ')}}`
 }
 
+/**
+ * Emit a typed Go slice-of-map literal (`[]map[string]interface{}{map[string]any{…}, …}`)
+ * for an untyped object-array Input field. Object elements become
+ * `map[string]any{"Field": val, …}` literals with PascalCase keys — Go
+ * template map lookup is case-sensitive, so `{{.Title}}` needs a capitalized
+ * key, same as the untyped `goArrayLiteralFromArray` fallback's object
+ * entries. `map[string]any` and `map[string]interface{}` are the identical
+ * type (`any` is the builtin alias for `interface{}`), so the emitted
+ * literal is assignable to `elemType` regardless of which spelling the
+ * Input struct field carries. (#2075, search-params-derived-filter)
+ */
+function goTypedMapSliceLiteralFromArray(arr: unknown[], elemType: string): string {
+  const entries = arr.map(v => {
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      return goMapLiteralFromObject(v as Record<string, unknown>, true)
+    }
+    if (typeof v === 'string') return `"${v.replace(/"/g, '\\"')}"`
+    if (typeof v === 'number' || typeof v === 'boolean') return String(v)
+    if (v === null) return 'nil'
+    return goArrayLiteralFromArray(v as unknown[])
+  })
+  return `[]${elemType}{${entries.join(', ')}}`
+}
+
 /**
  * Emit a keyed Go struct literal (`Elem{Field: val, …}`) with PascalCase field
  * names. Only the keys the caller supplied are set, so an omitted optional prop
@@ -703,7 +729,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`)