@barefootjs/go-template 0.1.0

package/src/adapter/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Go html/template Adapter Exports
+ */
+
+export { GoTemplateAdapter, goTemplateAdapter } from './go-template-adapter'
+export type { GoTemplateAdapterOptions } from './go-template-adapter'

package/src/build.ts

@@ -0,0 +1,258 @@
+// Go template build config factory for barefoot.config.ts
+
+import type { BuildOptions, PostBuildContext } from '@barefootjs/jsx'
+import { GoTemplateAdapter } from './adapter'
+import type { GoTemplateAdapterOptions } from './adapter'
+
+export interface GoTemplateBuildOptions extends BuildOptions {
+  /** Adapter-specific options passed to GoTemplateAdapter */
+  adapterOptions?: GoTemplateAdapterOptions
+  /** Output path for combined Go types file (relative to projectDir, default: 'components.go') */
+  typesOutputFile?: string
+  /** Transform the combined types string before writing (for app-specific type fixes) */
+  transformTypes?: (types: string) => string
+  /** Manual type definitions to append (app-specific types not generated from components) */
+  manualTypes?: string
+}
+
+// ── Go type helpers ──────────────────────────────────────────────────────
+
+/**
+ * Strip Go package header and import block, returning only type definitions.
+ */
+export function stripGoPackageHeader(types: string): string {
+  const lines = types.split('\n')
+  const packageEnd = lines.findIndex(l => l.startsWith('package '))
+  if (packageEnd < 0) return types
+
+  let startLine = packageEnd + 1
+  let inImportBlock = false
+
+  while (startLine < lines.length) {
+    const line = lines[startLine]
+    const trimmedLine = line?.trim() ?? ''
+
+    if (trimmedLine === '') {
+      startLine++
+      continue
+    }
+
+    // Single-line import: import "foo"
+    if (trimmedLine.startsWith('import ') && !trimmedLine.includes('(')) {
+      startLine++
+      continue
+    }
+
+    // Multi-line import block: import (
+    if (trimmedLine.startsWith('import (')) {
+      inImportBlock = true
+      startLine++
+      continue
+    }
+
+    if (inImportBlock) {
+      if (trimmedLine === ')') {
+        inImportBlock = false
+      }
+      startLine++
+      continue
+    }
+
+    break
+  }
+
+  return lines.slice(startLine).join('\n').trim()
+}
+
+/**
+ * Deduplicate Go type definitions and NewXxxProps constructor functions.
+ * When duplicates exist, prefer the version that contains ScopeID (the complete Props struct
+ * from generatePropsStruct) over the simplified version from typeDefinitions.
+ */
+export function deduplicateGoTypes(combined: string): string {
+  // --- Pass 1: Collect all type definitions, preferring ScopeID-containing versions ---
+  const typeRegex = /\/\/ \w+ (?:is|represents) .*\ntype (\w+) (?:struct\s*\{[\s\S]*?^\}|= \w+)/gm
+  const bestTypes = new Map<string, string>()
+  let match: RegExpExecArray | null
+  while ((match = typeRegex.exec(combined)) !== null) {
+    const typeName = match[1]
+    const fullMatch = match[0]
+    const existing = bestTypes.get(typeName)
+    if (!existing) {
+      bestTypes.set(typeName, fullMatch)
+    } else {
+      // Prefer the version with ScopeID (complete Props struct)
+      if (!existing.includes('ScopeID') && fullMatch.includes('ScopeID')) {
+        bestTypes.set(typeName, fullMatch)
+      }
+    }
+  }
+
+  // Remove all type definitions from the combined string
+  let result = combined.replace(typeRegex, '')
+
+  // Re-insert the best version of each type
+  const typeInsertions = Array.from(bestTypes.values()).join('\n\n')
+  // Insert types at the beginning (after any leading whitespace)
+  result = typeInsertions + '\n\n' + result
+
+  // --- Pass 2: Deduplicate NewXxxProps functions (prefer version with ScopeID) ---
+  const funcRegex = /\/\/ (New\w+Props) creates .*(?:\n\/\/.*)*\nfunc \1\([^)]*\) \w+ \{[\s\S]*?\n\}/g
+  const bestFuncs = new Map<string, string>()
+  while ((match = funcRegex.exec(result)) !== null) {
+    const funcName = match[1]
+    const fullMatch = match[0]
+    const existing = bestFuncs.get(funcName)
+    if (!existing) {
+      bestFuncs.set(funcName, fullMatch)
+    } else {
+      if (!existing.includes('ScopeID') && fullMatch.includes('ScopeID')) {
+        bestFuncs.set(funcName, fullMatch)
+      }
+    }
+  }
+
+  result = result.replace(funcRegex, '')
+  const funcInsertions = Array.from(bestFuncs.values()).join('\n\n')
+  if (funcInsertions) {
+    result = result + '\n\n' + funcInsertions
+  }
+
+  // Clean up multiple empty lines
+  return result.replace(/\n{3,}/g, '\n\n').trim()
+}
+
+/**
+ * Combine Go types from multiple components into a single .go file.
+ */
+export function combineGoTypes(options: {
+  types: Map<string, string>
+  packageName: string
+  manualTypes?: string
+  transformTypes?: (types: string) => string
+}): string {
+  const { types, packageName, manualTypes, transformTypes } = options
+
+  // Strip package headers and collect raw type bodies.
+  // A single types entry may contain multiple package headers (from multi-component files),
+  // so split on 'package ' boundaries and strip each section individually.
+  const typeBodies: string[] = []
+  for (const [, content] of types) {
+    // Split on package boundaries to handle multi-component files
+    const sections = content.split(/(?=^package \w+)/m)
+    for (const section of sections) {
+      const stripped = stripGoPackageHeader(section.trim())
+      if (stripped) typeBodies.push(stripped)
+    }
+  }
+
+  if (typeBodies.length === 0 && !manualTypes) return ''
+
+  // Combine and deduplicate
+  let combinedContent = deduplicateGoTypes(typeBodies.join('\n\n'))
+
+  // Apply app-specific transforms
+  if (transformTypes) {
+    combinedContent = transformTypes(combinedContent)
+  }
+
+  // Build final file
+  const parts = [
+    `// Code generated by BarefootJS. DO NOT EDIT.`,
+    `package ${packageName}`,
+    '',
+    `import (`,
+    `\t"math/rand"`,
+    '',
+    `\tbf "github.com/barefootjs/runtime/bf"`,
+    `)`,
+    '',
+    `// randomID generates a random string of length n for ScopeID.`,
+    `func randomID(n int) string {`,
+    `\tconst chars = "abcdefghijklmnopqrstuvwxyz0123456789"`,
+    `\tb := make([]byte, n)`,
+    `\tfor i := range b {`,
+    `\t\tb[i] = chars[rand.Intn(len(chars))]`,
+    `\t}`,
+    `\treturn string(b)`,
+    `}`,
+  ]
+
+  if (manualTypes) {
+    parts.push('', manualTypes)
+  }
+
+  if (combinedContent) {
+    parts.push('', combinedContent)
+  }
+
+  return parts.join('\n') + '\n'
+}
+
+// ── Config factory ───────────────────────────────────────────────────────
+
+/**
+ * Create a BarefootBuildConfig for Go html/template projects.
+ *
+ * Uses structural typing — does not import BarefootBuildConfig to avoid
+ * circular dependency between @barefootjs/go-template and @barefootjs/cli.
+ */
+export function createConfig(options: GoTemplateBuildOptions = {}) {
+  const packageName = options.adapterOptions?.packageName ?? 'main'
+  const typesOutputFile = options.typesOutputFile ?? 'components.go'
+
+  const postBuild = async (ctx: PostBuildContext) => {
+    if (ctx.types.size === 0) return
+
+    const content = combineGoTypes({
+      types: ctx.types,
+      packageName,
+      manualTypes: options.manualTypes,
+      transformTypes: options.transformTypes,
+    })
+
+    if (content) {
+      const { resolve } = await import('node:path')
+      const { readFile, writeFile } = await import('node:fs/promises')
+      const outPath = resolve(ctx.projectDir, typesOutputFile)
+      // Write only when content changed so cache-hit builds don't trip the
+      // dev-reload sentinel (ctx.markChanged) and trigger a spurious reload.
+      // Use node:fs/promises (not Bun.*) so this hook runs under either
+      // runtime — the published `barefoot` CLI bin starts via Node.
+      const prev = await readFile(outPath, 'utf-8').catch(() => null)
+      if (prev !== content) {
+        await writeFile(outPath, content)
+        ctx.markChanged?.()
+        console.log(`Generated: ${typesOutputFile}`)
+      }
+    }
+  }
+
+  // Chain user's postBuild with Go types generation
+  const userPostBuild = options.postBuild
+  const combinedPostBuild = userPostBuild
+    ? async (ctx: PostBuildContext) => {
+        await postBuild(ctx)
+        await userPostBuild(ctx)
+      }
+    : postBuild
+
+  return {
+    adapter: new GoTemplateAdapter(options.adapterOptions),
+    paths: options.paths,
+    components: options.components,
+    outDir: options.outDir,
+    minify: options.minify,
+    contentHash: options.contentHash,
+    externals: options.externals,
+    externalsBasePath: options.externalsBasePath,
+    bundleEntries: options.bundleEntries,
+    localImportPrefixes: options.localImportPrefixes,
+    outputLayout: options.outputLayout ?? {
+      templates: 'templates',
+      clientJs: 'client',
+      runtime: 'client',
+    },
+    postBuild: combinedPostBuild,
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+/**
+ * BarefootJS Go html/template Adapter
+ *
+ * Generates Go html/template files from BarefootJS IR.
+ */
+
+export { GoTemplateAdapter, goTemplateAdapter } from './adapter'
+export type { GoTemplateAdapterOptions } from './adapter'

package/src/test-render.ts

@@ -0,0 +1,363 @@
+/**
+ * Go Template test renderer
+ *
+ * Compiles JSX source with GoTemplateAdapter and renders to HTML via `go run`.
+ * Used by adapter-tests conformance runner.
+ */
+
+import { compileJSX } from '@barefootjs/jsx'
+import type { TemplateAdapter, ComponentIR } from '@barefootjs/jsx'
+import { mkdir, rm } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+const RENDER_TEMP_DIR = resolve(import.meta.dir, '../.render-temp')
+const GO_RUNTIME_DIR = resolve(import.meta.dir, '../runtime')
+
+export class GoNotAvailableError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'GoNotAvailableError'
+  }
+}
+
+let _goAvailable: boolean | null = null
+async function isGoAvailable(): Promise<boolean> {
+  if (_goAvailable !== null) return _goAvailable
+  try {
+    // If the caller pinned GOTOOLCHAIN to a specific version, run
+    // `go version` under it — `go` itself respects GOTOOLCHAIN and
+    // will auto-fetch the requested toolchain. This means the
+    // availability probe reports the *effective* version, not the
+    // system Go.
+    const env = { ...process.env, GOTOOLCHAIN: process.env.GOTOOLCHAIN ?? 'local' }
+    const proc = Bun.spawn(['go', 'version'], { stdout: 'pipe', stderr: 'pipe', env })
+    const stdout = await new Response(proc.stdout).text()
+    await proc.exited
+    if (proc.exitCode !== 0) { _goAvailable = false; return false }
+
+    // Check Go version is sufficient (go.mod requires 1.25+)
+    const match = stdout.match(/go(\d+)\.(\d+)/)
+    if (match) {
+      const major = parseInt(match[1], 10)
+      const minor = parseInt(match[2], 10)
+      _goAvailable = major > 1 || (major === 1 && minor >= 25)
+    } else {
+      _goAvailable = false
+    }
+  } catch {
+    _goAvailable = false
+  }
+  return _goAvailable
+}
+
+export interface RenderOptions {
+  /** JSX source code */
+  source: string
+  /** Template adapter to use */
+  adapter: TemplateAdapter
+  /** Props to inject (optional) */
+  props?: Record<string, unknown>
+  /** Additional component files (filename → source) */
+  components?: Record<string, string>
+}
+
+export async function renderGoTemplateComponent(options: RenderOptions): Promise<string> {
+  const { source, adapter, props, components } = options
+
+  if (!adapter.generateTypes) {
+    throw new Error('Go Template adapter must implement generateTypes()')
+  }
+
+  // Compile child components first
+  const childTemplates: string[] = []
+  const childTypeBlocks: string[] = []
+  if (components) {
+    for (const [filename, childSource] of Object.entries(components)) {
+      const childResult = compileJSX(childSource, filename, { adapter, outputIR: true })
+      const childErrors = childResult.errors.filter(e => e.severity === 'error')
+      if (childErrors.length > 0) {
+        throw new Error(`Compilation errors in ${filename}:\n${childErrors.map(e => e.message).join('\n')}`)
+      }
+      const childTemplate = childResult.files.find(f => f.type === 'markedTemplate')
+      if (!childTemplate) throw new Error(`No marked template for ${filename}`)
+      childTemplates.push(childTemplate.content)
+
+      const childIrFiles = childResult.files.filter(f => f.type === 'ir')
+      for (const childIrFile of childIrFiles) {
+        const childIR = JSON.parse(childIrFile.content) as ComponentIR
+        let childTypes = adapter.generateTypes!(childIR)
+        if (childTypes) {
+          // Strip package declaration and imports — will be merged into main types
+          childTypes = childTypes.replace(/^package \w+\n*/, '')
+          childTypes = childTypes.replace(/import\s*\([^)]*\)\n*/g, '')
+          childTypes = childTypes.replace(/\t"math\/rand"\n/g, '')
+          childTypeBlocks.push(childTypes.trim())
+        }
+      }
+    }
+  }
+
+  // Compile parent source
+  const result = compileJSX(source, 'component.tsx', { adapter, outputIR: true })
+
+  const errors = result.errors.filter(e => e.severity === 'error')
+  if (errors.length > 0) {
+    throw new Error(`Compilation errors:\n${errors.map(e => e.message).join('\n')}`)
+  }
+
+  const templateFile = result.files.find(f => f.type === 'markedTemplate')
+  if (!templateFile) throw new Error('No marked template in compile output')
+
+  // Collect every IR emitted from the parent source. Single-component
+  // files yield one file; multi-component files yield one per component
+  // (#1297). Pick the entry-point IR — default export wins, else the
+  // first inline-exported component, else the first IR.
+  const irFiles = result.files.filter(f => f.type === 'ir')
+  if (irFiles.length === 0) throw new Error('No IR output (set outputIR: true)')
+  const irs = irFiles.map(f => JSON.parse(f.content) as ComponentIR)
+  const ir =
+    irs.find(i => i.metadata.hasDefaultExport) ??
+    irs.find(i => i.metadata.isExported) ??
+    irs[0]
+
+  // Generate types for the entry-point component first, then append
+  // types for every sibling component in the same source file so the
+  // generated `types.go` is self-contained (multi-component test
+  // fixtures otherwise lose helper-component struct definitions).
+  let goTypes = adapter.generateTypes(ir)
+  if (!goTypes) throw new Error('generateTypes() returned null')
+
+  // Replace package declaration to match main.go
+  goTypes = goTypes.replace(/^package \w+/, 'package main')
+
+  // Remove "math/rand" import from types (randomID is defined in main.go)
+  goTypes = goTypes.replace(/\t"math\/rand"\n/, '')
+
+  // Append sibling-component type definitions (multi-component source).
+  for (const siblingIR of irs) {
+    if (siblingIR === ir) continue
+    let siblingTypes = adapter.generateTypes(siblingIR)
+    if (!siblingTypes) continue
+    siblingTypes = siblingTypes.replace(/^package \w+\n*/, '')
+    siblingTypes = siblingTypes.replace(/import\s*\([^)]*\)\n*/g, '')
+    siblingTypes = siblingTypes.replace(/\t"math\/rand"\n/g, '')
+    goTypes += '\n\n' + siblingTypes.trim()
+  }
+
+  // Append child type definitions
+  if (childTypeBlocks.length > 0) {
+    goTypes += '\n\n' + childTypeBlocks.join('\n\n')
+  }
+
+  const componentName = ir.metadata.componentName
+  // Concatenate all templates (child define blocks + parent)
+  const template = [...childTemplates, templateFile.content].join('\n')
+
+  // Build temp directory with Go files
+  const tempDir = resolve(
+    RENDER_TEMP_DIR,
+    `go-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  await mkdir(tempDir, { recursive: true })
+
+  try {
+    // go.mod with replace directive pointing to local runtime
+    const goMod = [
+      'module render-temp',
+      '',
+      'go 1.25.6',
+      '',
+      'require github.com/barefootjs/runtime/bf v0.0.0',
+      '',
+      `replace github.com/barefootjs/runtime/bf => ${GO_RUNTIME_DIR}`,
+    ].join('\n')
+    await Bun.write(resolve(tempDir, 'go.mod'), goMod)
+
+    // types.go — generated struct definitions
+    await Bun.write(resolve(tempDir, 'types.go'), goTypes)
+
+    // template content as Go raw string
+    const escapedTemplate = template.replace(/`/g, '` + "`" + `')
+
+    // Build props initialization
+    const propsInit = buildGoPropsInit(componentName, props)
+
+    // Honour `__instanceId` from props for the root scope id so
+    // shared-component fixtures (which pin `<ComponentName>_test`) match
+    // cross-adapter; default to 'test' otherwise.
+    const rootScopeId = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
+
+    // main.go — render program
+    const mainGo = `package main
+
+import (
+	"html/template"
+	"math/rand"
+	"os"
+
+	bf "github.com/barefootjs/runtime/bf"
+)
+
+// Silence unused import for bf if only FuncMap is used
+var _ = bf.FuncMap
+
+// Merge StreamingFuncMap into the base FuncMap so fixtures using
+// <Async> (which compiles to a bfAsyncBoundary call) can be parsed
+// by the test harness. See packages/adapter-go-template/runtime/streaming.go
+// for the recommended merge recipe.
+func bfTestFuncMap() template.FuncMap {
+	funcMap := bf.FuncMap()
+	for k, v := range bf.StreamingFuncMap() {
+		funcMap[k] = v
+	}
+	return funcMap
+}
+
+const tmplContent = \`${escapedTemplate}\`
+
+// randomID generates a random alphanumeric string of given length.
+// Required by generated NewXxxProps constructors.
+func randomID(n int) string {
+	const letters = "abcdefghijklmnopqrstuvwxyz0123456789"
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = letters[rand.Intn(len(letters))]
+	}
+	return string(b)
+}
+
+func main() {
+	tmpl := template.Must(template.New("").Funcs(bfTestFuncMap()).Parse(tmplContent))
+	props := New${componentName}Props(${componentName}Input{
+		ScopeID: ${JSON.stringify(rootScopeId)},
+${propsInit}
+	})
+	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
+		os.Stderr.WriteString("template error: " + err.Error() + "\\n")
+		os.Exit(1)
+	}
+}
+`
+    await Bun.write(resolve(tempDir, 'main.go'), mainGo)
+
+    // Check if Go is available
+    if (!await isGoAvailable()) {
+      throw new GoNotAvailableError('go command not found — skipping Go Template rendering')
+    }
+
+    // Run `go run .`
+    // GOTOOLCHAIN=local prevents Go from downloading a newer toolchain
+    // when go.mod specifies a patch version newer than the installed one.
+    // Honour a caller-supplied GOTOOLCHAIN env var so CI / dev environments
+    // with an older system Go can opt into Go's auto-download behaviour
+    // (e.g. `GOTOOLCHAIN=go1.25.6 bun test`).
+    const proc = Bun.spawn(['go', 'run', '.'], {
+      cwd: tempDir,
+      stdout: 'pipe',
+      stderr: 'pipe',
+      env: { ...process.env, GOTOOLCHAIN: process.env.GOTOOLCHAIN ?? 'local' },
+    })
+
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ])
+
+    const exitCode = await proc.exited
+    if (exitCode !== 0) {
+      throw new Error(`go run failed (exit ${exitCode}):\n${stderr}`)
+    }
+
+    return stdout
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {})
+  }
+}
+
+/**
+ * Build Go struct field initializers from props.
+ */
+function buildGoPropsInit(
+  _componentName: string,
+  props?: Record<string, unknown>,
+): string {
+  if (!props) return ''
+
+  const lines: string[] = []
+  for (const [key, value] of Object.entries(props)) {
+    // Skip internal hydration markers — `__instanceId` / `__bfScope`
+    // / `__bfChild` are routed by the framework (consumed via the
+    // separate `ScopeID` struct field for `__instanceId` and never
+    // appear on the user-facing input struct). Including them produces
+    // `unknown field __instanceId in struct literal of type XxxInput`.
+    if (key.startsWith('__')) continue
+    // Capitalize first letter for Go field name
+    const goField = key.charAt(0).toUpperCase() + key.slice(1)
+    if (typeof value === 'string') {
+      lines.push(`\t\t${goField}: "${value}",`)
+    } else if (typeof value === 'number') {
+      lines.push(`\t\t${goField}: ${value},`)
+    } else if (typeof value === 'boolean') {
+      lines.push(`\t\t${goField}: ${value},`)
+    } else if (Array.isArray(value)) {
+      // Array → Go `[]any` literal. Fixtures that exercise
+      // array-receiver methods (`items.every(...)`, `items.join(' - ')`,
+      // etc. — #1448 method catalog) need the prop value to reach
+      // the rendered template as a real slice so `range .Items` /
+      // `bf_join (.Items) ...` see actual elements; without this
+      // branch the prop was silently dropped, the input-struct
+      // field stayed at its zero value, and the template rendered
+      // empty content alongside the expected wrappers (the bug
+      // surfaced as "expected 'idx: 1' / got 'idx:'" on CI).
+      lines.push(`\t\t${goField}: ${goArrayLiteralFromArray(value)},`)
+    } 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
+      // Spread_<N> field that carries the destructured-rest payload.
+      // The same harness change is needed when any future fixture
+      // passes a `Record<string, unknown>`-shaped prop through.
+      lines.push(`\t\t${goField}: ${goMapLiteralFromObject(value as Record<string, unknown>)},`)
+    }
+  }
+  return lines.join('\n')
+}
+
+function goArrayLiteralFromArray(arr: unknown[]): string {
+  const entries: string[] = []
+  for (const v of arr) {
+    if (typeof v === 'string') entries.push(`"${v.replace(/"/g, '\\"')}"`)
+    else if (typeof v === 'number') entries.push(String(v))
+    else if (typeof v === 'boolean') entries.push(String(v))
+    else if (v === null) entries.push('nil')
+    else if (Array.isArray(v)) entries.push(goArrayLiteralFromArray(v))
+    else if (v && typeof v === 'object') {
+      // Objects inside arrays are accessed via Go-struct-style
+      // template field paths (`{{.Name}}`) and sort projections
+      // (`bf_sort ... "Price" ...`), both of which expect PascalCase
+      // identifiers. html/template does case-sensitive map lookup,
+      // so emit capitalized keys so `{{.Name}}` resolves directly
+      // without relying on the runtime's case-fallback. (#1487)
+      entries.push(goMapLiteralFromObject(v as Record<string, unknown>, true))
+    }
+  }
+  return `[]any{${entries.join(', ')}}`
+}
+
+function goMapLiteralFromObject(
+  obj: Record<string, unknown>,
+  capitalizeKeys = false,
+): string {
+  const entries: string[] = []
+  for (const [k, v] of Object.entries(obj)) {
+    const emittedKey = capitalizeKeys ? k.charAt(0).toUpperCase() + k.slice(1) : k
+    const key = JSON.stringify(emittedKey)
+    if (typeof v === 'string') entries.push(`${key}: "${v.replace(/"/g, '\\"')}"`)
+    else if (typeof v === 'number') entries.push(`${key}: ${v}`)
+    else if (typeof v === 'boolean') entries.push(`${key}: ${v}`)
+    else if (v === null) entries.push(`${key}: nil`)
+    else if (v && typeof v === 'object' && !Array.isArray(v)) {
+      entries.push(`${key}: ${goMapLiteralFromObject(v as Record<string, unknown>, capitalizeKeys)}`)
+    }
+  }
+  return `map[string]any{${entries.join(', ')}}`
+}