@barefootjs/go-template 0.1.2 → 0.1.3

package/dist/build.js

@@ -423,6 +423,7 @@ class GoTemplateAdapter extends BaseAdapter {
   errors = [];
   propsObjectName = null;
   restPropsName = null;
+  templateVarCounter = 0;
   localTypeNames = new Set;
   localTypeAliases = new Map;
   usesHtmlTemplate = false;
@@ -437,6 +438,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) {
@@ -776,7 +778,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);
@@ -785,7 +787,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;
@@ -861,7 +863,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`);
@@ -882,9 +884,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`);
@@ -906,7 +908,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`;
@@ -1054,7 +1056,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
           });
         }
       }
@@ -1877,7 +1880,7 @@ ${goFields.join(`
     if (literalType === "string")
       return `"${value}"`;
     if (literalType === "null")
-      return '""';
+      return "nil";
     return String(value);
   }
   call(callee, args, emit) {
@@ -1913,7 +1916,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}}`;
@@ -2017,7 +2020,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;
@@ -2157,12 +2160,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;
   }
@@ -2178,6 +2186,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) {
@@ -2186,11 +2203,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;
   }
@@ -2219,6 +2238,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);
@@ -2339,7 +2374,7 @@ ${goFields.join(`
           return `"${expr.value}"`;
         }
         if (expr.literalType === "null") {
-          return '""';
+          return "nil";
         }
         return String(expr.value);
       case "member": {
@@ -2616,138 +2651,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) {