@barefootjs/go-template 0.1.2 → 0.1.3

package/src/adapter/go-template-adapter.ts

@@ -71,6 +71,7 @@ type GoRenderCtx = {
  */
 interface NestedComponentInfo extends IRLoopChildComponent {
   isDynamic: boolean
+  isPropDerived: boolean
 }
 
 interface StaticChildInstance {
@@ -308,6 +309,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * follow-up).
    */
   private restPropsName: string | null = null
+  private templateVarCounter: number = 0
   /** Local type names resolved from typeDefinitions (populated during generateTypes) */
   private localTypeNames: Set<string> = new Set()
   /** Local type aliases mapping type name to base type (e.g., Filter → 'string') */
@@ -334,6 +336,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput {
     this.componentName = ir.metadata.componentName
     this.errors = []
+    this.templateVarCounter = 0
     this.propsObjectName = ir.metadata.propsObjectName
     this.restPropsName = ir.metadata.restPropsName ?? null
 
@@ -807,8 +810,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     lines.push('\tBfParent string // Optional: parent scope id')
     lines.push('\tBfMount string // Optional: slot id in parent')
 
-    // Static nested components appear in Input; dynamic ones are template-only
-    const staticNested = nestedComponents.filter(n => !n.isDynamic)
+    // Static + prop-derived nested components appear in Input;
+    // signal-backed dynamic ones are template-only
+    const inputNested = nestedComponents.filter(n => !n.isDynamic || n.isPropDerived)
 
     // Collect nested component array field names to skip from propsParams
     const nestedArrayFields = new Set(nestedComponents.map(n => `${n.name}s`))
@@ -821,8 +825,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\t${fieldName} ${goType}`)
     }
 
-    // Add nested component input arrays (static only)
-    for (const nested of staticNested) {
+    // Add nested component input arrays
+    for (const nested of inputNested) {
       lines.push(`\t${nested.name}s []${nested.name}Input`)
     }
 
@@ -953,10 +957,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     // Add array fields for nested components (for template rendering)
     for (const nested of nestedComponents) {
-      if (nested.isDynamic) {
-        // Dynamic (signal) array loops: template-only, not in JSON
+      if (nested.isDynamic && !nested.isPropDerived) {
+        // Dynamic signal array loops: template-only, not in JSON
         lines.push(`\t${nested.name}s []${nested.name}Props \`json:"-"\``)
       } else {
+        // Static arrays and prop-derived dynamic arrays: include in JSON
+        // so the client can hydrate via mapArray or forEach
         const jsonTag = this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`)
         lines.push(`\t${nested.name}s []${nested.name}Props \`json:"${jsonTag}"\``)
       }
@@ -1005,9 +1011,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // field, the SSR template iterates over it, but
     // `NewTodoAppProps(TodoAppInput{Initial: ...})` returns it empty
     // and the page renders a blank list (#1442 echo TodoApp repro).
-    const dynamicNested = nestedComponents.filter(n => n.isDynamic)
+    const signalDynamicNested = nestedComponents.filter(n => n.isDynamic && !n.isPropDerived)
     lines.push(`// New${componentName}Props creates ${propsTypeName} from ${inputTypeName}.`)
-    for (const nested of dynamicNested) {
+    for (const nested of signalDynamicNested) {
       const arrayField = `${nested.name}s`
       lines.push(`//`)
       lines.push(`// NOTE: \`${arrayField}\` is populated by the route handler, not by`)
@@ -1030,8 +1036,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     lines.push('\t}')
     lines.push('')
 
-    // Static nested components only — dynamic ones are set manually by the handler
-    const staticNested = nestedComponents.filter(n => !n.isDynamic)
+    // Static + prop-derived nested components: auto-populate from input.
+    // Signal-backed dynamic arrays are set manually by the handler.
+    const staticNested = nestedComponents.filter(n => !n.isDynamic || n.isPropDerived)
 
     // Handle nested components
     if (staticNested.length > 0) {
@@ -1266,6 +1273,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           result.push({
             ...loop.childComponent,
             isDynamic: !loop.isStaticArray,
+            isPropDerived: !!loop.isPropDerivedArray,
           })
         }
       }
@@ -2471,7 +2479,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
     if (literalType === 'string') return `"${value}"`
-    if (literalType === 'null') return '""'
+    if (literalType === 'null') return 'nil'
     return String(value)
   }
 
@@ -2530,8 +2538,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (result) return result
     }
 
-    // find().property → {{with bf_find ...}}{{.Property}}{{end}}
-    if (object.kind === 'higher-order' && object.method === 'find') {
+    // find().property / findLast().property → {{with bf_find ...}}{{.Property}}{{end}}
+    if (object.kind === 'higher-order' && (object.method === 'find' || object.method === 'findLast')) {
       const findResult = this.renderHigherOrderExpr(object, emit)
       if (findResult) {
         return `{{with ${findResult}}}{{.${this.capitalizeFieldName(property)}}}{{end}}`
@@ -2613,6 +2621,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `or ${wrapLeft} ${wrapRight}`
   }
 
+  // Note: JSX-level ternaries (`{expr ? a : b}`) are handled at the
+  // IR level as IRConditional, which goes through convertConditionToGo
+  // → renderConditionExpr (preamble-aware). This emitter method is
+  // only reached for ternaries nested inside other ParsedExpr trees
+  // (e.g. template-literal interpolation), where the test is always a
+  // simple pipeline expression (runtime helpers, not template blocks).
   conditional(
     test: ParsedExpr,
     consequent: ParsedExpr,
@@ -2620,8 +2634,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     emit: (e: ParsedExpr) => string,
   ): string {
     const t = emit(test)
-    // Nested conditionals already return complete {{if}}...{{end}} blocks;
-    // literals return bare text (used within attributes).
     const c = this.renderConditionalBranch(consequent)
     const a = this.renderConditionalBranch(alternate)
     return `{{if ${t}}}${c}{{else}}${a}{{end}}`
@@ -2672,7 +2684,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const reconstructed = { kind: 'higher-order' as const, method, object, param, predicate }
     const result = this.renderHigherOrderExpr(reconstructed, emit)
     if (result) return result
-    if (method === 'find' || method === 'findIndex') {
+    if (method === 'find' || method === 'findIndex' || method === 'findLast' || method === 'findLastIndex') {
       const templateBlock = this.renderFindTemplateBlock(reconstructed, emit)
       if (templateBlock) return templateBlock
     }
@@ -2941,26 +2953,29 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return `bf_filter ${arrayExpr} "${field}" ${value}`
     }
 
-    if (expr.method === 'find' || expr.method === 'findIndex') {
+    if (expr.method === 'find' || expr.method === 'findIndex' || expr.method === 'findLast' || expr.method === 'findLastIndex') {
       const eqPred = this.extractEqualityPredicate(
         expr.predicate, expr.param, e => this.renderParsedExpr(e)
       )
       if (!eqPred) return null
-      const func = expr.method === 'find' ? 'bf_find' : 'bf_find_index'
-      return `${func} ${arrayExpr} "${eqPred.field}" ${eqPred.value}`
+      const funcMap: Record<string, string> = {
+        find: 'bf_find', findIndex: 'bf_find_index',
+        findLast: 'bf_find_last', findLastIndex: 'bf_find_last_index',
+      }
+      return `${funcMap[expr.method]} ${arrayExpr} "${eqPred.field}" ${eqPred.value}`
     }
 
     return null
   }
 
   /**
-   * Render find()/findIndex() with complex predicates using {{range}}{{if}}...{{break}} blocks.
-   * Falls back from bf_find/bf_find_index when extractEqualityPredicate returns null.
-   * Reuses renderFilterExpr for condition rendering.
+   * Render find/findIndex/findLast/findLastIndex with complex predicates
+   * using range/if blocks. Falls back from bf_find/bf_find_last helpers
+   * when extractEqualityPredicate returns null.
    *
-   * @param expr - The higher-order find/findIndex expression
-   * @param renderArray - Function to render the array expression
-   * @param propertyAccess - Optional property to access on the found element (for find().property)
+   * find/findIndex use break on first match (forward scan).
+   * findLast/findLastIndex iterate forward and keep overwriting a result
+   * variable; the final value is the last match.
    */
   private renderFindTemplateBlock(
     expr: Extract<ParsedExpr, { kind: 'higher-order' }>,
@@ -2980,6 +2995,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return `{{range $i, $_ := ${arrayExpr}}}{{if ${condition}}}{{$i}}{{break}}{{end}}{{end}}`
     }
 
+    if (expr.method === 'findLast') {
+      const v = `$bf_r${this.templateVarCounter++}`
+      const capture = propertyAccess ? `.${propertyAccess}` : '.'
+      return `{{${v} := ""}}{{range ${arrayExpr}}}{{if ${condition}}}{{${v} = ${capture}}}{{end}}{{end}}{{${v}}}`
+    }
+
+    if (expr.method === 'findLastIndex') {
+      const v = `$bf_r${this.templateVarCounter++}`
+      return `{{${v} := -1}}{{range $i, $_ := ${arrayExpr}}}{{if ${condition}}}{{${v} = $i}}{{end}}{{end}}{{${v}}}`
+    }
+
     return null
   }
 
@@ -3003,13 +3029,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (condition.includes('[UNSUPPORTED')) return null
 
     if (expr.method === 'every') {
-      // Negate condition: if NOT condition, set false and break
+      const v = `$bf_r${this.templateVarCounter++}`
       const negated = this.negateGoCondition(condition)
-      return `{{$bf_result := true}}{{range ${arrayExpr}}}{{if ${negated}}}{{$bf_result = false}}{{break}}{{end}}{{end}}{{$bf_result}}`
+      return `{{${v} := true}}{{range ${arrayExpr}}}{{if ${negated}}}{{${v} = false}}{{break}}{{end}}{{end}}{{${v}}}`
     }
 
     if (expr.method === 'some') {
-      return `{{$bf_result := false}}{{range ${arrayExpr}}}{{if ${condition}}}{{$bf_result = true}}{{break}}{{end}}{{end}}{{$bf_result}}`
+      const v = `$bf_r${this.templateVarCounter++}`
+      return `{{${v} := false}}{{range ${arrayExpr}}}{{if ${condition}}}{{${v} = true}}{{break}}{{end}}{{end}}{{${v}}}`
     }
 
     return null
@@ -3068,6 +3095,28 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return expr.kind === 'logical' || expr.kind === 'unary' || expr.kind === 'conditional'
   }
 
+  /**
+   * Split a rendered template block into preamble + final expression.
+   * The last `{{...}}` must be a variable reference (`$bf_rN` or
+   * `$bf_result`). Control tokens like `{{end}}` or `{{break}}` are
+   * rejected — those template blocks (e.g. find's range/break form)
+   * can't be composed in binary/logical expressions.
+   */
+  private splitPreamble(rendered: string): { preamble: string; expr: string } | null {
+    if (!rendered.includes('{{')) return null
+    const lastOpen = rendered.lastIndexOf('{{')
+    const lastClose = rendered.lastIndexOf('}}')
+    if (lastOpen >= 0 && lastClose > lastOpen) {
+      const candidate = rendered.substring(lastOpen + 2, lastClose)
+      if (!candidate.startsWith('$')) return null
+      return {
+        preamble: rendered.substring(0, lastOpen),
+        expr: candidate,
+      }
+    }
+    return null
+  }
+
   // =============================================================================
   // Block Body Condition Rendering
   // =============================================================================
@@ -3310,7 +3359,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           return `"${expr.value}"`
         }
         if (expr.literalType === 'null') {
-          return '""'
+          return 'nil'
         }
         return String(expr.value)
 
@@ -3682,196 +3731,149 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return { condition: `false`, preamble: '' }
     }
 
-    const rendered = this.renderConditionExpr(parsed)
-
-    // Detect template blocks (e.g., from every/some with complex predicates).
-    // These cannot be placed inside {{if ...}} directly.
-    // Split into preamble (template block) + condition variable.
-    if (rendered.startsWith('{{')) {
-      const lastOpen = rendered.lastIndexOf('{{')
-      const lastClose = rendered.lastIndexOf('}}')
-      if (lastOpen >= 0 && lastClose > lastOpen) {
-        const preamble = rendered.substring(0, lastOpen)
-        const condition = rendered.substring(lastOpen + 2, lastClose)
-        return { condition, preamble }
-      }
-    }
-
-    return { condition: rendered, preamble: '' }
+    const { preamble, expr: condition } = this.renderConditionExpr(parsed)
+    return { condition, preamble }
   }
 
-  /**
-   * Render a ParsedExpr as a Go template condition.
-   */
-  private renderConditionExpr(expr: ParsedExpr): string {
+  private renderConditionExpr(expr: ParsedExpr): { preamble: string; expr: string } {
+    const plain = (e: string) => ({ preamble: '', expr: e })
+
     switch (expr.kind) {
       case 'identifier':
-        // Inside a `{{range $_, $todo := .Todos}}` loop, a bare reference
-        // to the loop variable (`todo`) is just Go template's dot. The
-        // `ParsedExprEmitter` path already handles this at memberAccess
-        // (line ~2449); this condition-expression path needs the same
-        // normalization or `todo.done` ends up as `.Todo.Done` — a
-        // non-existent field that Go template silently expands to ""
-        // and then aborts the surrounding `{{if}}`/template execution
-        // (echo logs it as a 200 with truncated bytes; #1442 repro).
         {
           const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1]
           if (currentLoopParam && expr.name === currentLoopParam) {
-            return '.'
+            return plain('.')
           }
         }
-        return `.${this.capitalizeFieldName(expr.name)}`
+        return plain(`.${this.capitalizeFieldName(expr.name)}`)
 
       case 'literal':
-        if (expr.literalType === 'string') {
-          return `"${expr.value}"`
-        }
-        if (expr.literalType === 'null') {
-          return '""'
-        }
-        return String(expr.value)
+        if (expr.literalType === 'string') return plain(`"${expr.value}"`)
+        if (expr.literalType === 'null') return plain('nil')
+        return plain(String(expr.value))
 
       case 'call': {
-        // Signal call: count() -> .Count
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
-          return `.${this.capitalizeFieldName(expr.callee.name)}`
+          return plain(`.${this.capitalizeFieldName(expr.callee.name)}`)
         }
-        return this.renderParsedExpr(expr)
+        return plain(this.renderParsedExpr(expr))
       }
 
       case 'member': {
-        // Handle .length with higher-order filter → len (bf_filter ...)
         if (expr.property === 'length' && expr.object.kind === 'higher-order') {
-          const result = this.renderFilterLengthExpr(expr.object, e => this.renderConditionExpr(e))
-          if (result) {
-            return result
-          }
+          // renderFilterLengthExpr uses bf_filter runtime helpers (not
+          // template blocks), so .preamble is always empty here today.
+          // If a future higher-order method produces preambles through
+          // this path, the callback would need to propagate them.
+          const result = this.renderFilterLengthExpr(expr.object, e => this.renderConditionExpr(e).expr)
+          if (result) return plain(result)
         }
 
-        // Handle SolidJS-style props pattern: props.xxx -> .Xxx
         if (expr.object.kind === 'identifier' && this.propsObjectName && expr.object.name === this.propsObjectName) {
-          return `.${this.capitalizeFieldName(expr.property)}`
+          return plain(`.${this.capitalizeFieldName(expr.property)}`)
         }
 
-        // Loop-param member access: `todo.done` inside
-        // `{{range $_, $todo := .Todos}}` is `.Done` (Go template's dot
-        // is the current item). The `ParsedExprEmitter` already does
-        // this for renderParsedExpr; mirror it here so condition-only
-        // positions like boolean attributes (`checked={todo.done}`)
-        // and `{{if}}` operands don't fall through to the generic
-        // `.Todo.Done` shape, which references a non-existent field.
         {
           const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1]
           if (expr.object.kind === 'identifier' && currentLoopParam && expr.object.name === currentLoopParam) {
-            return `.${this.capitalizeFieldName(expr.property)}`
+            return plain(`.${this.capitalizeFieldName(expr.property)}`)
           }
         }
 
         const obj = this.renderConditionExpr(expr.object)
         if (expr.property === 'length') {
-          return `len ${obj}`
+          return { preamble: obj.preamble, expr: `len ${obj.expr}` }
         }
-        return `${obj}.${this.capitalizeFieldName(expr.property)}`
+        return { preamble: obj.preamble, expr: `${obj.expr}.${this.capitalizeFieldName(expr.property)}` }
       }
 
       case 'binary': {
-        // Check if left operand needs parentheses (e.g., function calls in Go template)
         const leftNeedsParens = this.needsParensInGoTemplate(expr.left)
-        let left = this.renderConditionExpr(expr.left)
-        if (leftNeedsParens) {
-          left = `(${left})`
-        }
+        const leftResult = this.renderConditionExpr(expr.left)
+        const left = leftNeedsParens ? `(${leftResult.expr})` : leftResult.expr
 
         const rightNeedsParens = this.needsParensInGoTemplate(expr.right)
-        let right = this.renderConditionExpr(expr.right)
-        if (rightNeedsParens) {
-          right = `(${right})`
-        }
+        const rightResult = this.renderConditionExpr(expr.right)
+        const right = rightNeedsParens ? `(${rightResult.expr})` : rightResult.expr
 
+        const preamble = leftResult.preamble + rightResult.preamble
+
+        let result: string
         switch (expr.op) {
           case '===':
           case '==':
-            return `eq ${left} ${right}`
+            result = `eq ${left} ${right}`; break
           case '!==':
           case '!=':
-            return `ne ${left} ${right}`
+            result = `ne ${left} ${right}`; break
           case '>':
-            return `gt ${left} ${right}`
+            result = `gt ${left} ${right}`; break
           case '<':
-            return `lt ${left} ${right}`
+            result = `lt ${left} ${right}`; break
           case '>=':
-            return `ge ${left} ${right}`
+            result = `ge ${left} ${right}`; break
           case '<=':
-            return `le ${left} ${right}`
-          // Arithmetic in conditions
+            result = `le ${left} ${right}`; break
           case '+':
-            return `bf_add ${left} ${right}`
+            result = `bf_add ${left} ${right}`; break
           case '-':
-            return `bf_sub ${left} ${right}`
+            result = `bf_sub ${left} ${right}`; break
           case '*':
-            return `bf_mul ${left} ${right}`
+            result = `bf_mul ${left} ${right}`; break
           case '/':
-            return `bf_div ${left} ${right}`
+            result = `bf_div ${left} ${right}`; break
           default:
-            return `${left} ${expr.op} ${right}`
+            result = `${left} ${expr.op} ${right}`
         }
+        return { preamble, expr: result }
       }
 
       case 'unary': {
         const arg = this.renderConditionExpr(expr.argument)
-        if (expr.op === '!') {
-          return `not ${arg}`
-        }
-        if (expr.op === '-') {
-          return `bf_neg ${arg}`
-        }
+        if (expr.op === '!') return { preamble: arg.preamble, expr: `not ${arg.expr}` }
+        if (expr.op === '-') return { preamble: arg.preamble, expr: `bf_neg ${arg.expr}` }
         return arg
       }
 
       case 'logical': {
-        const left = this.renderConditionExpr(expr.left)
-        const right = this.renderConditionExpr(expr.right)
-        // Wrap in parentheses if needed
-        const wrapLeft = this.needsParens(expr.left) ? `(${left})` : left
-        const wrapRight = this.needsParens(expr.right) ? `(${right})` : right
-        if (expr.op === '&&') {
-          return `and ${wrapLeft} ${wrapRight}`
-        }
-        return `or ${wrapLeft} ${wrapRight}`
+        const leftResult = this.renderConditionExpr(expr.left)
+        const rightResult = this.renderConditionExpr(expr.right)
+        const preamble = leftResult.preamble + rightResult.preamble
+        const wrapLeft = this.needsParens(expr.left) ? `(${leftResult.expr})` : leftResult.expr
+        const wrapRight = this.needsParens(expr.right) ? `(${rightResult.expr})` : rightResult.expr
+        const result = expr.op === '&&'
+          ? `and ${wrapLeft} ${wrapRight}`
+          : `or ${wrapLeft} ${wrapRight}`
+        return { preamble, expr: result }
       }
 
       case 'conditional': {
-        // Ternary in condition: (cond ? a : b) is unusual but handle it
         const test = this.renderConditionExpr(expr.test)
-        return test // Just return the test part for condition context
+        return test
       }
 
       case 'template-literal':
-        // Template literals as conditions are unusual
-        return this.renderParsedExpr(expr)
+        return plain(this.renderParsedExpr(expr))
 
       case 'arrow-fn':
-        // Arrow functions shouldn't appear in conditions
-        return '[ARROW-FN]'
+        return plain('[ARROW-FN]')
 
-      case 'higher-order':
-        // Higher-order methods in conditions need special handling
-        return this.renderParsedExpr(expr)
+      case 'higher-order': {
+        const rendered = this.renderParsedExpr(expr)
+        const split = this.splitPreamble(rendered)
+        if (split) return split
+        return plain(rendered)
+      }
 
       case 'array-literal':
-        // Array literals in conditions have no Go template form —
-        // delegate to renderParsedExpr so the `arrayLiteral` BF101
-        // gate fires consistently with non-condition positions.
-        return this.renderParsedExpr(expr)
+        return plain(this.renderParsedExpr(expr))
 
       case 'array-method':
-        // Same delegation pattern — `arrayMethod` records the
-        // refusal diagnostic at one site rather than duplicating it
-        // for condition-position emission.
-        return this.renderParsedExpr(expr)
+        return plain(this.renderParsedExpr(expr))
 
       case 'unsupported':
-        return expr.raw
+        return plain(expr.raw)
     }
   }