@barefootjs/go-template 0.18.3 → 0.18.5

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

@@ -42,8 +42,12 @@ export function convertInitialValue(
       return value === 'true' ? 'true' : 'false'
     }
     if (typeInfo.primitive === 'number') {
-      if (/^\d+$/.test(value)) return value
-      if (/^\d+\.\d+$/.test(value)) return value
+      // Leading `-` (#2168 math-methods: `createSignal(-7.6)`) — without it,
+      // a negative initial value never matches either literal shape below
+      // and silently falls to the `0` zero-value fallback, regardless of the
+      // field's Go type.
+      if (/^-?\d+$/.test(value)) return value
+      if (/^-?\d+\.\d+$/.test(value)) return value
       return '0'
     }
     if (typeInfo.primitive === 'string') {
@@ -70,6 +74,27 @@ export function convertInitialValue(
       }
       return '""'
     }
+    // A struct-backed `interface` kind (an explicitly-typed object signal,
+    // `createSignal<User>({...})`) — #2168 signal-object-field. Mirrors the
+    // `array` branch above: `jsLiteralToGo` → `parsedLiteralToGo`'s
+    // object-literal case already bakes an object literal against a named
+    // local struct correctly (proven by the existing typed-array-of-objects
+    // test); it just wasn't reachable from a SCALAR struct signal, which
+    // fell straight through to `nil` — a compile error for a non-pointer
+    // struct field (`cannot use nil as User value in struct literal`), not
+    // merely a silently-dropped initial value.
+    if (ctx.state.localStructFields.has(typeInfo.raw)) {
+      const baked = jsLiteralToGo(ctx, typeInfo, preParsed)
+      if (baked !== null) return baked
+      // Baking failed (a non-literal initial value, or no `preParsed` tree)
+      // — `nil` is STILL invalid Go for this non-pointer struct field, so
+      // the same compile error would resurface for any such case (Copilot
+      // review, #2201). The struct's own zero value (`User{}`) is the
+      // correct fallback here — mirrors this function's own docstring
+      // ("falls back to the type's zero value") for every other typed
+      // branch above.
+      return `${typeInfo.raw}{}`
+    }
   }
 
   return 'nil'

package/src/conformance-pins.ts

@@ -138,9 +138,4 @@ export const conformancePins: ConformancePins = {
   // the shape loudly instead of emitting entity-escaped markup that
   // silently renders tags as text.
   'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `.replaceAll` has no lowering yet —
-  // only first-occurrence `.replace` is wired to the runtime helpers.
-  // Refused with BF101 rather than reusing the first-only lowering,
-  // which would silently change semantics.
-  'string-replaceall': [{ code: 'BF101', severity: 'error' }],
 }

package/src/render-divergences.ts

@@ -17,40 +17,4 @@
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
-  'html-entity-text':
-    '`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes',
-  'string-concat-plus':
-    "`'Hello, ' + name` renders \"0\" — JS string-concat `+` lowered through numeric addition",
-  'optional-chaining-prop':
-    '`user?.name ?? …` on an object prop: generated Go fails to run (exit 1) — optional chaining into a struct/map prop has no lowering',
-  'number-tofixed':
-    '`.toFixed(2)` on a number PROP: generated Go fails to run (exit 1)',
-  'math-methods':
-    'Math.min/max/abs over a signal: generated Go fails to run (exit 1) — only Math.floor is registered',
-  'boolean-attr-literals':
-    'camelCase boolean alias `readOnly`: Hono SSRs `readOnly="true"`, this adapter emits bare presence',
-  'camelcase-attributes':
-    '`htmlFor` is not lowered to `for` (Hono maps it)',
-  'static-attr-escape':
-    'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  'svg-icon':
-    'SVG camelCase presentation attrs (`strokeWidth`, `strokeLinecap`) pass through unmapped; Hono lowers to kebab-case',
-  'object-entries-map':
-    '`Object.entries(prop).map(([k, v]) => …)`: generated Go fails to run (exit 1) — no object-iteration loop lowering',
-  'nested-loop-outer-binding':
-    'nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`',
-  'jsx-element-prop':
-    'a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped',
-  'grandchild-composition':
-    "three-level composition: the grandchild's threaded prop renders EMPTY — prop forwarding through two template-render layers loses the value",
-  'child-primitive-props':
-    'numeric/boolean LITERAL props on a child (`count={5}` `active={true}`) render as Go zero values (0 / false)',
-  'memo-chain':
-    'a memo derived from another memo renders EMPTY for the second layer — the constructor folds only one derivation level',
-  'signal-object-field':
-    'object-valued signal (`user().name`): generated Go fails to run (exit 1) — no struct synthesis outside loops',
-  'string-slice':
-    '`.slice()` on a STRING routes through the array `bf_slice` helper and renders "[]" instead of the substring',
-  'string-trim-sided':
-    '`.trimStart()` / `.trimEnd()`: generated Go fails to run (exit 1) — only both-sides `bf_trim` exists',
 }

package/src/test-render.ts

@@ -9,7 +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'
-import { capitalizeFieldName } from './adapter/lib/go-naming.ts'
+import { capitalizeFieldName, goFieldNameForKey } from './adapter/lib/go-naming.ts'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -572,9 +572,7 @@ function buildGoPropsInit(
   // in struct literal of type InputInput`. (#1467 Phase 2b)
   const declaredParams = new Set((ir?.metadata.propsParams ?? []).map(p => p.name))
   const restPropsName = ir?.metadata.restPropsName ?? null
-  const restBagField = restPropsName
-    ? restPropsName.charAt(0).toUpperCase() + restPropsName.slice(1)
-    : null
+  const restBagField = restPropsName ? capitalizeFieldName(restPropsName) : null
 
   const lines: string[] = []
   const restBagEntries: Array<[string, unknown]> = []
@@ -594,8 +592,9 @@ function buildGoPropsInit(
       restBagEntries.push([key, value])
       continue
     }
-    // Capitalize first letter for Go field name
-    const goField = key.charAt(0).toUpperCase() + key.slice(1)
+    // Same Go-initialism-aware capitalizer as the real adapter (`id` → `ID`,
+    // not the naive `Id`) — see `goMapLiteralFromObject`'s identical fix.
+    const goField = capitalizeFieldName(key)
     if (typeof value === 'string') {
       lines.push(`\t\t${goField}: "${value}",`)
     } else if (typeof value === 'number') {
@@ -729,7 +728,11 @@ function goTypedMapSliceLiteralFromArray(arr: unknown[], elemType: string): stri
 function goStructLiteral(obj: Record<string, unknown>, typeName: string): string {
   const fields: string[] = []
   for (const [k, v] of Object.entries(obj)) {
-    const goField = capitalizeFieldName(k)
+    // `goFieldNameForKey`, not the bare `capitalizeFieldName` — a data-driven
+    // key here can be non-identifier-shaped (`'data-x'`), and the real
+    // adapter's own struct-literal baking (`parsed-literal-to-go.ts`)
+    // sanitizes those to `DataX`, not `Data-x` (Copilot review, #2202).
+    const goField = goFieldNameForKey(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`)
@@ -766,7 +769,19 @@ function goMapLiteralFromObject(
 ): string {
   const entries: string[] = []
   for (const [k, v] of Object.entries(obj)) {
-    const emittedKey = capitalizeKeys ? k.charAt(0).toUpperCase() + k.slice(1) : k
+    // `goFieldNameForKey`, not a naive first-letter uppercase and not the
+    // bare `capitalizeFieldName` — #2168 nested-loop-triple-depth: a naive
+    // capitalize disagrees with the real adapter's Go-initialism-aware
+    // field naming for a key like `id` (naive → "Id", adapter's generated
+    // struct/template field → "ID"), so the harness baked a literal the
+    // template's `{{.ID}}` lookup could never match — the fixture's
+    // rendered fields came back empty at EVERY nesting depth for this
+    // reason, not because of any depth limit. `capitalizeFieldName` alone
+    // fixes the initialism case but still mis-bakes a non-identifier key
+    // (`'data-x'` → `"Data-x"`, not the adapter's own `"DataX"` —
+    // Copilot review, #2202); `goFieldNameForKey` is what the real adapter
+    // uses for exactly this key-to-Go-field sanitization.
+    const emittedKey = capitalizeKeys ? goFieldNameForKey(k) : 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}`)