@barefootjs/go-template 0.1.1 → 0.1.3

package/dist/index.js

@@ -83,6 +83,7 @@ class GoTemplateAdapter extends BaseAdapter {
   errors = [];
   propsObjectName = null;
   restPropsName = null;
+  templateVarCounter = 0;
   localTypeNames = new Set;
   localTypeAliases = new Map;
   usesHtmlTemplate = false;
@@ -97,6 +98,7 @@ class GoTemplateAdapter extends BaseAdapter {
   generate(ir, options) {
     this.componentName = ir.metadata.componentName;
     this.errors = [];
+    this.templateVarCounter = 0;
     this.propsObjectName = ir.metadata.propsObjectName;
     this.restPropsName = ir.metadata.restPropsName ?? null;
     if (!options?.siblingTemplatesRegistered) {
@@ -436,7 +438,7 @@ ${goFields.join(`
     lines.push("\tScopeID string // Optional: if empty, random ID is generated");
     lines.push("\tBfParent string // Optional: parent scope id");
     lines.push("\tBfMount string // Optional: slot id in parent");
-    const staticNested = nestedComponents.filter((n) => !n.isDynamic);
+    const inputNested = nestedComponents.filter((n) => !n.isDynamic || n.isPropDerived);
     const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
     for (const param of ir.metadata.propsParams) {
       const fieldName = this.capitalizeFieldName(param.name);
@@ -445,7 +447,7 @@ ${goFields.join(`
       const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue);
       lines.push(`	${fieldName} ${goType}`);
     }
-    for (const nested of staticNested) {
+    for (const nested of inputNested) {
       lines.push(`	${nested.name}s []${nested.name}Input`);
     }
     const restPropsName = ir.metadata.restPropsName;
@@ -521,7 +523,7 @@ ${goFields.join(`
       lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
     }
     for (const nested of nestedComponents) {
-      if (nested.isDynamic) {
+      if (nested.isDynamic && !nested.isPropDerived) {
         lines.push(`	${nested.name}s []${nested.name}Props \`json:"-"\``);
       } else {
         const jsonTag = this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`);
@@ -542,9 +544,9 @@ ${goFields.join(`
   generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots) {
     const inputTypeName = `${componentName}Input`;
     const propsTypeName = `${componentName}Props`;
-    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`);
@@ -566,7 +568,7 @@ ${goFields.join(`
     lines.push(`		scopeID = "${componentName}_" + randomID(6)`);
     lines.push("\t}");
     lines.push("");
-    const staticNested = nestedComponents.filter((n) => !n.isDynamic);
+    const staticNested = nestedComponents.filter((n) => !n.isDynamic || n.isPropDerived);
     if (staticNested.length > 0) {
       for (const nested of staticNested) {
         const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
@@ -714,7 +716,8 @@ ${goFields.join(`
         if (!result.some((c) => c.name === loop.childComponent.name)) {
           result.push({
             ...loop.childComponent,
-            isDynamic: !loop.isStaticArray
+            isDynamic: !loop.isStaticArray,
+            isPropDerived: !!loop.isPropDerivedArray
           });
         }
       }
@@ -1537,7 +1540,7 @@ ${goFields.join(`
     if (literalType === "string")
       return `"${value}"`;
     if (literalType === "null")
-      return '""';
+      return "nil";
     return String(value);
   }
   call(callee, args, emit) {
@@ -1573,7 +1576,7 @@ ${goFields.join(`
       if (result)
         return result;
     }
-    if (object.kind === "higher-order" && object.method === "find") {
+    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}}`;
@@ -1677,7 +1680,7 @@ ${goFields.join(`
     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;
@@ -1817,12 +1820,17 @@ ${goFields.join(`
       const value = negated ? "false" : "true";
       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 = {
+        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;
   }
@@ -1838,6 +1846,15 @@ ${goFields.join(`
     if (expr.method === "findIndex") {
       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;
   }
   renderEverySomeTemplateBlock(expr, renderArray) {
@@ -1846,11 +1863,13 @@ ${goFields.join(`
     if (condition.includes("[UNSUPPORTED"))
       return null;
     if (expr.method === "every") {
+      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;
   }
@@ -1879,6 +1898,22 @@ ${goFields.join(`
   needsParens(expr) {
     return expr.kind === "logical" || expr.kind === "unary" || expr.kind === "conditional";
   }
+  splitPreamble(rendered) {
+    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;
+  }
   renderBlockBodyCondition(statements, param) {
     const localVarMap = new Map;
     const paths = this.collectReturnPaths(statements, [], localVarMap, param);
@@ -1999,7 +2034,7 @@ ${goFields.join(`
           return `"${expr.value}"`;
         }
         if (expr.literalType === "null") {
-          return '""';
+          return "nil";
         }
         return String(expr.value);
       case "member": {
@@ -2276,138 +2311,138 @@ Options:
       });
       return { condition: `false`, preamble: "" };
     }
-    const rendered = this.renderConditionExpr(parsed);
-    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 };
   }
   renderConditionExpr(expr) {
+    const plain = (e) => ({ preamble: "", expr: e });
     switch (expr.kind) {
       case "identifier":
         {
           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": {
         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": {
         if (expr.property === "length" && expr.object.kind === "higher-order") {
-          const result = this.renderFilterLengthExpr(expr.object, (e) => this.renderConditionExpr(e));
-          if (result) {
-            return result;
-          }
+          const result = this.renderFilterLengthExpr(expr.object, (e) => this.renderConditionExpr(e).expr);
+          if (result)
+            return plain(result);
         }
         if (expr.object.kind === "identifier" && this.propsObjectName && expr.object.name === this.propsObjectName) {
-          return `.${this.capitalizeFieldName(expr.property)}`;
+          return plain(`.${this.capitalizeFieldName(expr.property)}`);
         }
         {
           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": {
         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;
         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}`;
+            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);
-        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": {
         const test = this.renderConditionExpr(expr.test);
         return test;
       }
       case "template-literal":
-        return this.renderParsedExpr(expr);
+        return plain(this.renderParsedExpr(expr));
       case "arrow-fn":
-        return "[ARROW-FN]";
-      case "higher-order":
-        return this.renderParsedExpr(expr);
+        return plain("[ARROW-FN]");
+      case "higher-order": {
+        const rendered = this.renderParsedExpr(expr);
+        const split = this.splitPreamble(rendered);
+        if (split)
+          return split;
+        return plain(rendered);
+      }
       case "array-literal":
-        return this.renderParsedExpr(expr);
+        return plain(this.renderParsedExpr(expr));
       case "array-method":
-        return this.renderParsedExpr(expr);
+        return plain(this.renderParsedExpr(expr));
       case "unsupported":
-        return expr.raw;
+        return plain(expr.raw);
     }
   }
   renderLoop(loop) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,11 +49,11 @@
     "directory": "packages/adapter-go-template"
   },
   "peerDependencies": {
-    "@barefootjs/jsx": "0.1.1",
+    "@barefootjs/jsx": "0.1.3",
     "typescript": "^5.0.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.1.1"
+    "@barefootjs/jsx": "0.1.3"
   }
 }

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

@@ -22,14 +22,6 @@ runAdapterConformanceTests({
   // `<!--bf-cond-start:sN-->` / `<!--bf-cond-end:sN-->` comment pairs)
   // is now collapsed by `normalizeHTML` in adapter-tests (#1266).
   //
-  // `nullish-coalescing-jsx` / `return-nullish-coalescing` have a
-  // separate semantic divergence: the Go template's `{{if ne .Banner
-  // ""}}` condition treats an unset `Banner` (Go nil) as `!= ""` and
-  // takes the truthy branch with empty content, while Hono's JS
-  // `??` operator falls through to the JSX default. That's a Go-
-  // adapter branch-selection bug — fixing it is out of scope for
-  // #1266.
-  //
   // `return-map` uses a `data-key` serialisation shape that differs
   // between Hono (runtime helper) and Go (template variable) in a
   // way that isn't structural — leaving it on `skipJsx` until a
@@ -43,8 +35,6 @@ runAdapterConformanceTests({
   // `BF104` at build time instead of silently emitting invalid
   // template syntax (#1266).
   skipJsx: [
-    'nullish-coalescing-jsx',
-    'return-nullish-coalescing',
     'return-map',
     // #1297 fixed the harness-side IR emission gate (multi-component
     // sources now emit one `ir` file per component, and the harness
@@ -1034,6 +1024,116 @@ export function ItemChecker() {
     })
   })
 
+  describe('findLast/findLastIndex - adapter specific', () => {
+    test('renders findLast() with equality predicate via bf_find_last', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { name: string; done: boolean }
+
+export function ItemChecker() {
+  const [items, setItems] = createSignal<Item[]>([])
+  return <div>{items().findLast(t => t.done) ? 'Found' : 'Not found'}</div>
+}
+`)
+      expect(result.template).toContain('bf_find_last .Items "Done" true')
+      expect(result.template).toContain('Found')
+    })
+
+    test('renders findLast() with complex predicate via range without break', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; category: string }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  const [type, setType] = createSignal('')
+  return <div>{items().findLast(t => t.price > 100 && t.category === type())}</div>
+}
+`)
+      expect(result.template).toContain('{{range')
+      expect(result.template).toContain('$bf_r')
+      expect(result.template).not.toContain('{{break}}')
+    })
+
+    test('renders findLastIndex() with equality predicate via bf_find_last_index', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { name: string; done: boolean }
+
+export function ItemChecker() {
+  const [items, setItems] = createSignal<Item[]>([])
+  return <div>idx: {items().findLastIndex(t => t.done)}</div>
+}
+`)
+      expect(result.template).toContain('bf_find_last_index .Items "Done" true')
+    })
+
+    test('renders findLastIndex() with complex predicate via range', () => {
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; active: boolean }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  return <div>{items().findLastIndex(t => t.price > 50 && t.active)}</div>
+}
+`)
+      const varMatch = result.template.match(/(\$bf_r\d+) := -1/)
+      expect(varMatch).not.toBeNull()
+      expect(result.template).toContain(`${varMatch![1]} = $i`)
+      expect(result.template).not.toContain('{{break}}')
+    })
+
+    test('findLast() complex predicate in IR-level ternary works via preamble splitting', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; category: string }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  const [type, setType] = createSignal('')
+  return <div>{items().findLast(t => t.price > 100 && t.category === type()) ? 'yes' : 'no'}</div>
+}
+`, adapter)
+      const output = adapter.generate(ir)
+      expect(adapter.errors.filter(e => e.code === 'BF101')).toEqual([])
+      expect(output.template).toMatch(/\$bf_r\d+ := ""/)
+      expect(output.template).toContain('yes')
+    })
+
+    test('findLast() complex predicate in binary expression compiles via preamble hoisting', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type Item = { price: number; category: string }
+
+export function ItemFinder() {
+  const [items, setItems] = createSignal<Item[]>([])
+  const [type, setType] = createSignal('')
+  return <div class={items().findLast(t => t.price > 100 && t.category === type()) === 'special' ? 'highlight' : 'normal'}>test</div>
+}
+`, adapter)
+      const output = adapter.generate(ir)
+      expect(adapter.errors.filter(e => e.code === 'BF101')).toEqual([])
+      expect(output.template).toMatch(/\$bf_r\d+ := ""/)
+      expect(output.template).toContain('eq')
+      expect(output.template).toContain('"special"')
+    })
+  })
+
   describe('component root scope comment propagation', () => {
     test('component root in client component outputs bfScopeComment', () => {
       const result = compileAndGenerate(`