@barefootjs/go-template 0.18.5 → 0.18.7

package/dist/build.js

@@ -365,7 +365,7 @@ var init_path = __esm(() => {
 import {
   BaseAdapter,
   isBooleanAttr,
-  parseExpression as parseExpression3,
+  parseExpression as parseExpression4,
   stringifyParsedExpr as stringifyParsedExpr2,
   parseStyleObjectEntries,
   isSupported,
@@ -383,7 +383,13 @@ import {
   prepareLoweringMatchers,
   envSignalReaderFor,
   computeSsrSeedPlan,
-  isStringConcatBinary
+  isStringConcatBinary,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  collectLoopBoundNames as collectLoopBoundNames2,
+  evaluateStaticLiteral as evaluateStaticLiteral3
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
 import { BF_REGION, escapeHtml } from "@barefootjs/shared";
@@ -689,6 +695,7 @@ class CompileState {
   restPropsName = null;
   moduleStringConsts = new Map;
   localConstants = [];
+  staticLoopSourceBoundNames = new Set;
   localHelperNames = new Set;
   currentMemos = [];
   currentTypeDefinitions = [];
@@ -857,6 +864,178 @@ function collectNestedComponents(node, result) {
   }
 }
 
+// src/adapter/analysis/static-child-loop-bake.ts
+import { evaluateStaticLiteral, parseExpression, resolveStaticLoopSource } from "@barefootjs/jsx";
+function scalarToGoLiteral(value) {
+  if (typeof value === "string")
+    return `"${escapeGoString(value)}"`;
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  return null;
+}
+function analyzeBakeableStaticChildLoop(nested, localConstants, opts) {
+  if (!nested.loopParam || /^[{[]/.test(nested.loopParam))
+    return null;
+  const staticItemsResult = resolveStaticLoopSource(nested.loopArrayParsed, localConstants, opts);
+  if (staticItemsResult === null)
+    return null;
+  const items = [];
+  for (const item of staticItemsResult) {
+    const bindings = new Map([[nested.loopParam, item]]);
+    const inputFields = [];
+    for (const prop of nested.props) {
+      if (prop.isEventHandler)
+        continue;
+      if (prop.name.includes("-"))
+        continue;
+      const resolved = resolvePropValue(prop.value, bindings);
+      if (resolved === undefined)
+        return null;
+      const goValue = scalarToGoLiteral(resolved);
+      if (goValue === null)
+        return null;
+      inputFields.push({ goField: capitalizeFieldName(prop.name), goValue });
+    }
+    let dataKey = null;
+    if (nested.loopKey) {
+      const keyExpr = parseExpression(nested.loopKey);
+      const keyResolved = evaluateStaticLiteral(keyExpr, bindings);
+      if (keyResolved === null)
+        return null;
+      dataKey = String(keyResolved.value);
+    }
+    items.push({ inputFields, dataKey });
+  }
+  return { items };
+}
+function resolvePropValue(value, bindings) {
+  switch (value.kind) {
+    case "literal":
+      return value.value;
+    case "boolean-shorthand":
+    case "boolean-attr":
+      return true;
+    case "expression": {
+      if (!value.parsed)
+        return;
+      const resolved = evaluateStaticLiteral(value.parsed, bindings);
+      return resolved === null ? undefined : resolved.value;
+    }
+    default:
+      return;
+  }
+}
+
+// src/adapter/analysis/static-element-loop-bake.ts
+import {
+  evaluateStaticLiteral as evaluateStaticLiteral2,
+  resolveStaticLoopSource as resolveStaticLoopSource2
+} from "@barefootjs/jsx";
+var ALLOWED_ATTR_EXPRESSION_KINDS = new Set([
+  "identifier",
+  "member",
+  "index-access",
+  "literal"
+]);
+function analyzeBakeableStaticElementLoop(loop, localConstants, opts) {
+  if (loop.childComponent)
+    return null;
+  if (loop.method === "flatMap" || loop.flatMapCallback)
+    return null;
+  if (!loop.param || /^[{[]/.test(loop.param))
+    return null;
+  if (loop.index && loop.index !== "_")
+    return null;
+  if (loop.paramBindings && loop.paramBindings.length > 0)
+    return null;
+  if (loop.filterPredicate || loop.sortComparator)
+    return null;
+  if (loop.iterationShape || loop.objectIteration)
+    return null;
+  if (loop.bodyIsMultiRoot || loop.bodyIsItemConditional)
+    return null;
+  if (!isFoldableTree(loop.children))
+    return null;
+  const items = resolveStaticLoopSource2(loop.arrayParsed, localConstants, opts);
+  if (items === null)
+    return null;
+  for (const item of items) {
+    const bindings = new Map([[loop.param, item]]);
+    if (!allExpressionsFoldFor(loop.children, bindings))
+      return null;
+  }
+  return { items };
+}
+function isFoldableTree(nodes) {
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+      case "expression":
+        continue;
+      case "element":
+        if (!isFoldableAttrs(node))
+          return false;
+        if (!isFoldableTree(node.children))
+          return false;
+        continue;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+function isFoldableAttrs(element) {
+  for (const attr of element.attrs) {
+    if (attr.clientOnly)
+      continue;
+    switch (attr.value.kind) {
+      case "literal":
+      case "boolean-attr":
+      case "boolean-shorthand":
+        continue;
+      case "expression":
+        if (!attr.value.parsed || !ALLOWED_ATTR_EXPRESSION_KINDS.has(attr.value.parsed.kind))
+          return false;
+        continue;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+function allExpressionsFoldFor(nodes, bindings) {
+  for (const node of nodes) {
+    if (node.type === "expression") {
+      if (node.clientOnly)
+        continue;
+      if (!node.parsed || !resolvesToScalar(node.parsed, bindings))
+        return false;
+      continue;
+    }
+    if (node.type === "element") {
+      for (const attr of node.attrs) {
+        if (attr.clientOnly)
+          continue;
+        if (attr.value.kind !== "expression")
+          continue;
+        if (!attr.value.parsed || !resolvesToScalar(attr.value.parsed, bindings))
+          return false;
+      }
+      if (!allExpressionsFoldFor(node.children, bindings))
+        return false;
+    }
+  }
+  return true;
+}
+function resolvesToScalar(expr, bindings) {
+  const resolved = evaluateStaticLiteral2(expr, bindings);
+  if (resolved === null)
+    return false;
+  return scalarToGoLiteral(resolved.value) !== null;
+}
+
 // src/adapter/expr/helper-inline.ts
 function inlineLocalHelperCall(ctx, jsExpr, callParsed) {
   if (ctx.state.localHelperNames.size === 0)
@@ -1044,7 +1223,7 @@ function forEachValueChild(n, visit) {
 
 // src/adapter/expr/url-builder.ts
 import {
-  parseExpression,
+  parseExpression as parseExpression2,
   stringifyParsedExpr,
   isValidHelperId
 } from "@barefootjs/jsx";
@@ -1077,7 +1256,7 @@ function lowerRegisteredCall(ctx, jsExpr, preParsed) {
   if (!call) {
     if (!/^\s*[A-Za-z_$][\w$]*\s*\(/.test(jsExpr))
       return null;
-    const parsed = parseExpression(jsExpr);
+    const parsed = parseExpression2(jsExpr);
     if (parsed.kind !== "call")
       return null;
     call = parsed;
@@ -2171,7 +2350,7 @@ function propsAccessNameFromParsed2(ctx, node) {
 
 // src/adapter/spread/spread-codegen.ts
 import ts2 from "typescript";
-import { parseExpression as parseExpression2, parseRecordIndexAccess } from "@barefootjs/jsx";
+import { parseExpression as parseExpression3, parseRecordIndexAccess } from "@barefootjs/jsx";
 function collectSpreadSlots(ctx, node) {
   const result = [];
   collectSpreadSlotsRecursive(ctx, node, result);
@@ -2278,7 +2457,7 @@ function parsedObjectLiteralToGoMap(parsed) {
 }
 function buildSpreadInitializer(ctx, spreadExpr, ir, parsed) {
   const trimmed = spreadExpr.trim();
-  const conditionalTree = parsed ?? parseExpression2(trimmed);
+  const conditionalTree = parsed ?? parseExpression3(trimmed);
   const conditional = buildConditionalSpreadInitializer(ctx, conditionalTree, ir);
   if (conditional !== undefined)
     return conditional;
@@ -2309,7 +2488,7 @@ function buildSpreadInitializer(ctx, spreadExpr, ir, parsed) {
     if (localConst?.value !== undefined) {
       const initTrimmed = localConst.value.trim();
       if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(initTrimmed)) {
-        const resolved = buildConditionalSpreadInitializer(ctx, parseExpression2(initTrimmed), ir);
+        const resolved = buildConditionalSpreadInitializer(ctx, parseExpression3(initTrimmed), ir);
         if (resolved)
           return resolved;
         if (resolved === null)
@@ -2500,6 +2679,7 @@ function collectNillablePropNames(ctx, ir) {
 }
 
 // src/adapter/props/prop-classes.ts
+import { collectLoopBoundNames } from "@barefootjs/jsx";
 function isStringTypeInfo(type) {
   return type.kind === "primitive" && type.primitive === "string";
 }
@@ -2520,6 +2700,13 @@ function collectStringValueNames(ir) {
     if (isStringTypeInfo(p.type))
       names.add(p.name);
   }
+  for (const c of ir.metadata.localConstants) {
+    if (c.type !== null && isStringTypeInfo(c.type) || isBareStringLiteral(c.value)) {
+      names.add(c.name);
+    }
+  }
+  for (const bound of collectLoopBoundNames(ir))
+    names.delete(bound);
   return names;
 }
 
@@ -2564,6 +2751,7 @@ class GoTemplateAdapter extends BaseAdapter {
     return this.state.errors;
   }
   inLoop = false;
+  bakedStaticChildLoopCache = new Map;
   loopParamStack = [];
   loopKeyDepthStack = [];
   loopScalarItemStack = [];
@@ -2571,6 +2759,8 @@ class GoTemplateAdapter extends BaseAdapter {
   loopVarRefCount = new Map;
   loopBindingStack = [];
   loopRestExcludeStack = [];
+  staticLoopItemStack = [];
+  staticLoopBakeFailed = false;
   childComponentShapes = new Map;
   childContextConsumers = new Map;
   constructor(options = {}) {
@@ -2586,6 +2776,8 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.restPropsName = ir.metadata.restPropsName ?? null;
     this.state.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
     this.state.localConstants = ir.metadata.localConstants ?? [];
+    this.state.staticLoopSourceBoundNames = collectLoopBoundNames2(ir);
+    this.bakedStaticChildLoopCache = new Map;
     this.state.localHelperNames = new Set(this.state.localConstants.filter((c) => !c.isModule && c.containsArrow).map((c) => c.name));
     this.state.currentMemos = ir.metadata.memos ?? [];
     this.state.currentTypeDefinitions = ir.metadata.typeDefinitions ?? [];
@@ -2967,6 +3159,8 @@ ${goFields.join(`
       lines.push(`	${fieldName} ${goType}`);
     }
     for (const nested of inputNested) {
+      if (nested.loopMarkerId && this.getBakedStaticChildLoop(nested.loopMarkerId, nested, nested.loopArrayParsed, nested.loopParam, nested.loopKey))
+        continue;
       lines.push(`	${nested.name}s []${nested.name}Input`);
     }
     const takenInput = new Set(ir.metadata.propsParams.map((p) => capitalizeFieldName(p.name)));
@@ -3098,6 +3292,21 @@ ${goFields.join(`
     const staticWithoutBody = staticNested.filter((n) => !n.bodyChildren || n.bodyChildren.length === 0);
     for (const nested of staticWithoutBody) {
       const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
+      const baked = nested.loopMarkerId ? this.getBakedStaticChildLoop(nested.loopMarkerId, nested, nested.loopArrayParsed, nested.loopParam, nested.loopKey) : null;
+      if (baked) {
+        lines.push(`	${varName} := make([]${nested.name}Props, ${baked.items.length})`);
+        baked.items.forEach((item, i) => {
+          const fields = item.inputFields.map((f) => `${f.goField}: ${f.goValue}`).join(", ");
+          lines.push(`	${varName}[${i}] = New${nested.name}Props(${nested.name}Input{${fields}})`);
+          lines.push(`	${varName}[${i}].BfParent = scopeID`);
+          lines.push(`	${varName}[${i}].BfMount = "${nested.slotId}"`);
+          if (item.dataKey !== null) {
+            lines.push(`	${varName}[${i}].BfDataKey = ${JSON.stringify(item.dataKey)}`);
+          }
+        });
+        lines.push("");
+        continue;
+      }
       lines.push(`	${varName} := make([]${nested.name}Props, len(in.${nested.name}s))`);
       lines.push(`	for i, item := range in.${nested.name}s {`);
       lines.push(`		${varName}[i] = New${nested.name}Props(item)`);
@@ -4151,7 +4360,8 @@ ${goFields.join(`
   renderElement(element) {
     const tag = element.tag;
     const attrs = this.renderAttributes(element);
-    const children = this.renderChildren(element.children);
+    const dangerousHtml = this.renderDangerousInnerHtml(element);
+    const children = dangerousHtml !== null ? dangerousHtml : this.renderChildren(element.children);
     let hydrationAttrs = "";
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker(".ScopeID")}`;
@@ -4186,6 +4396,22 @@ ${goFields.join(`
     }
     return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
   }
+  renderDangerousInnerHtml(element) {
+    const resolution = resolveDangerousInnerHtml(element);
+    if (!resolution)
+      return null;
+    if (resolution.kind === "dynamic") {
+      this.errors.push(dangerousInnerHtmlDiagnostic(resolution.expr, resolution.loc));
+      return "";
+    }
+    const violation = dangerousInnerHtmlMetacharViolation(resolution.html, this.name);
+    if (violation) {
+      const attr = element.attrs.find(isDangerousInnerHtmlAttr);
+      this.errors.push(dangerousInnerHtmlDiagnostic(`{ __html: ${JSON.stringify(resolution.html)} }`, attr.loc, violation));
+      return "";
+    }
+    return resolution.html;
+  }
   renderExpression(expr) {
     if (expr.clientOnly) {
       if (expr.slotId) {
@@ -4919,8 +5145,8 @@ ${goFields.join(`
     const value = negated ? "false" : "true";
     return `len (bf_filter ${arrayExpr} "${field}" ${value})`;
   }
-  renderPredicateCondition(pred, param) {
-    return this.renderFilterExpr(pred, param);
+  renderPredicateCondition(pred, param, datumField) {
+    return this.renderFilterExpr(pred, param, new Map, datumField ?? undefined);
   }
   needsParens(expr) {
     return expr.kind === "logical" || expr.kind === "unary" || expr.kind === "conditional";
@@ -4941,21 +5167,23 @@ ${goFields.join(`
     }
     return null;
   }
-  renderFilterExpr(expr, param, localVarMap = new Map) {
+  renderFilterExpr(expr, param, localVarMap = new Map, datumField) {
     if (this.filterExprDepth === 0)
       this.filterExprUnsupported = false;
     this.filterExprDepth++;
     try {
-      return this.renderFilterExprNode(expr, param, localVarMap);
+      return this.renderFilterExprNode(expr, param, localVarMap, datumField);
     } finally {
       this.filterExprDepth--;
     }
   }
-  renderFilterExprNode(expr, param, localVarMap) {
+  renderFilterExprNode(expr, param, localVarMap, datumField) {
+    const paramPrefix = datumField ? `.${datumField}` : "";
+    const paramDot = paramPrefix || ".";
     switch (expr.kind) {
       case "identifier": {
         if (expr.name === param) {
-          return ".";
+          return paramDot;
         }
         const signal = localVarMap.get(expr.name);
         if (signal) {
@@ -4973,24 +5201,24 @@ ${goFields.join(`
         return String(expr.value);
       case "member": {
         if (expr.object.kind === "identifier" && expr.object.name === param) {
-          return `.${capitalizeFieldName(expr.property)}`;
+          return `${paramPrefix}.${capitalizeFieldName(expr.property)}`;
         }
         if (expr.property === "length") {
           const innerHO = this.higherOrderShapeOf(expr.object);
           if (innerHO && innerHO.method === "filter") {
-            const lenExpr = this.renderFilterLengthExpr(innerHO, (e) => this.renderFilterExpr(e, param, localVarMap));
+            const lenExpr = this.renderFilterLengthExpr(innerHO, (e) => this.renderFilterExpr(e, param, localVarMap, datumField));
             if (lenExpr)
               return `(${lenExpr})`;
           }
         }
-        const obj = this.renderFilterExpr(expr.object, param, localVarMap);
+        const obj = this.renderFilterExpr(expr.object, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         return `${obj}.${capitalizeFieldName(expr.property)}`;
       }
       case "call": {
         if (expr.callee.kind === "member" && expr.callee.object.kind === "identifier" && expr.callee.object.name === param) {
-          return `.${capitalizeFieldName(expr.callee.property)}`;
+          return `${paramPrefix}.${capitalizeFieldName(expr.callee.property)}`;
         }
         if (expr.callee.kind === "identifier" && expr.args.length === 0) {
           return `$.${capitalizeFieldName(expr.callee.name)}`;
@@ -4998,13 +5226,13 @@ ${goFields.join(`
         if (asCallbackMethodCall3(expr) !== null) {
           return this.refuseFilterExprNode(expr);
         }
-        const result = this.renderFilterExpr(expr.callee, param, localVarMap);
+        const result = this.renderFilterExpr(expr.callee, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         return result;
       }
       case "unary": {
-        const arg = this.renderFilterExpr(expr.argument, param, localVarMap);
+        const arg = this.renderFilterExpr(expr.argument, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         if (expr.op === "!") {
@@ -5017,10 +5245,10 @@ ${goFields.join(`
         return arg;
       }
       case "binary": {
-        const left = this.renderFilterExpr(expr.left, param, localVarMap);
+        const left = this.renderFilterExpr(expr.left, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
-        const right = this.renderFilterExpr(expr.right, param, localVarMap);
+        const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         switch (expr.op) {
@@ -5051,10 +5279,10 @@ ${goFields.join(`
         }
       }
       case "logical": {
-        const left = this.renderFilterExpr(expr.left, param, localVarMap);
+        const left = this.renderFilterExpr(expr.left, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
-        const right = this.renderFilterExpr(expr.right, param, localVarMap);
+        const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         if (expr.op === "&&") {
@@ -5122,11 +5350,22 @@ ${goFields.join(`
     if (trimmed === "null" || trimmed === "undefined") {
       return '""';
     }
+    if (this.staticLoopItemStack.length > 0) {
+      const top = this.staticLoopItemStack[this.staticLoopItemStack.length - 1];
+      const parsedForBake = preParsed ?? parseExpression4(trimmed);
+      const resolved = evaluateStaticLiteral3(parsedForBake, new Map([[top.param, top.item]]));
+      const literal = resolved !== null ? scalarToGoLiteral(resolved.value) : null;
+      if (literal !== null) {
+        return literal;
+      }
+      this.staticLoopBakeFailed = true;
+      return '""';
+    }
     const staticIndexed = this.resolveStaticRecordLiteralIndex(trimmed);
     if (staticIndexed !== null) {
       return staticIndexed;
     }
-    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+    if (!this.isLoopShadowedName(trimmed) && /^[A-Za-z_$][\w$]*$/.test(trimmed)) {
       const litConst = (this.state.localConstants ?? []).find((c) => c.name === trimmed);
       if (litConst?.value !== undefined) {
         const v = litConst.value.trim();
@@ -5144,7 +5383,7 @@ ${goFields.join(`
     if (inlined !== null) {
       return this.convertExpressionToGo(stringifyParsedExpr2(inlined), out, inlined);
     }
-    const parsed = preParsed ?? parseExpression3(trimmed);
+    const parsed = preParsed ?? parseExpression4(trimmed);
     const support = isSupported(parsed);
     if (!support.supported) {
       this.state.errors.push({
@@ -5162,10 +5401,15 @@ ${goFields.join(`
       out.parsed = parsed;
     return this.renderParsedExpr(parsed);
   }
+  isLoopShadowedName(name) {
+    return this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name || this.loopVarRefCount.has(name) || this.isOuterLoopParam(name) || this.loopBindingStack.some((bindings) => bindings.has(name));
+  }
   resolveStaticRecordLiteralIndex(jsExpr) {
     const m = /^([A-Za-z_$][\w$]*)\[\s*(?:'([^']*)'|"([^"]*)")\s*\]$/.exec(jsExpr) ?? /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(jsExpr);
     if (!m)
       return null;
+    if (this.isLoopShadowedName(m[1]))
+      return null;
     const key = m[2] ?? m[3];
     const constInfo = (this.state.localConstants ?? []).find((c) => c.name === m[1] && c.isModule);
     if (constInfo?.value === undefined)
@@ -5271,7 +5515,7 @@ ${goFields.join(`
   }
   convertConditionToGo(jsCondition, preParsed) {
     const trimmed = jsCondition.trim();
-    const parsed = preParsed ?? parseExpression3(trimmed);
+    const parsed = preParsed ?? parseExpression4(trimmed);
     const support = isSupported(parsed);
     if (!support.supported) {
       this.state.errors.push({
@@ -5492,6 +5736,29 @@ ${goFields.join(`
     }
     return;
   }
+  wrapperDatumField(loop) {
+    if (!loop.childComponent)
+      return null;
+    for (const prop of loop.childComponent.props) {
+      if (prop.isEventHandler)
+        continue;
+      if (prop.value.kind !== "expression")
+        continue;
+      const parsed = prop.value.parsed;
+      const isBareParamRef = parsed ? parsed.kind === "identifier" && parsed.name === loop.param : prop.value.expr.trim() === loop.param;
+      if (isBareParamRef)
+        return capitalizeFieldName(prop.name);
+    }
+    return null;
+  }
+  getBakedStaticChildLoop(markerId, childComponent, arrayParsed, param, key) {
+    if (this.bakedStaticChildLoopCache.has(markerId)) {
+      return this.bakedStaticChildLoopCache.get(markerId) ?? null;
+    }
+    const result = analyzeBakeableStaticChildLoop({ props: childComponent.props, loopArrayParsed: arrayParsed, loopParam: param, loopKey: key }, this.state.localConstants, { isNameShadowed: (name) => this.state.staticLoopSourceBoundNames.has(name) });
+    this.bakedStaticChildLoopCache.set(markerId, result);
+    return result;
+  }
   renderLoop(loop) {
     if (loop.clientOnly) {
       return `{{bfComment "loop:${loop.markerId}"}}{{bfComment "/loop:${loop.markerId}"}}`;
@@ -5512,8 +5779,13 @@ ${goFields.join(`
         }
       });
     }
+    const bakedChildLoop = loop.childComponent ? this.getBakedStaticChildLoop(loop.markerId, loop.childComponent, loop.arrayParsed, loop.param, loop.key ?? undefined) : null;
+    const bakedElementLoop = loop.childComponent ? null : analyzeBakeableStaticElementLoop(loop, this.state.localConstants, { isNameShadowed: (name) => this.state.staticLoopSourceBoundNames.has(name) });
+    if (bakedElementLoop) {
+      return this.renderUnrolledStaticElementLoop(loop, bakedElementLoop.items);
+    }
     const arrayName = loop.array.trim();
-    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+    if (bakedChildLoop === null && /^[A-Za-z_$][\w$]*$/.test(arrayName)) {
       const arrayConst = this.state.localConstants.find((c) => c.name === arrayName);
       if (arrayConst && !arrayConst.isModule && arrayConst.parsed && !this.isStringExpr(arrayConst.parsed, new Set)) {
         this.state.errors.push({
@@ -5527,7 +5799,7 @@ ${goFields.join(`
         });
       }
     }
-    let goArray = this.convertExpressionToGo(loop.array);
+    let goArray = loop.childComponent ? "" : this.convertExpressionToGo(loop.array);
     const param = loop.param;
     let index = loop.index || "_";
     let rangeIndex = index;
@@ -5595,7 +5867,8 @@ ${goFields.join(`
     if (loop.filterPredicate) {
       let filterCond;
       if (loop.filterPredicate.predicate) {
-        filterCond = this.renderPredicateCondition(loop.filterPredicate.predicate, loop.filterPredicate.param);
+        const datumField = this.wrapperDatumField(loop);
+        filterCond = this.renderPredicateCondition(loop.filterPredicate.predicate, loop.filterPredicate.param, datumField);
       } else {
         filterCond = "true";
       }
@@ -5603,6 +5876,38 @@ ${goFields.join(`
     }
     return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
   }
+  renderUnrolledStaticElementLoop(loop, items) {
+    this.inLoop = true;
+    this.loopWrapperStack.push(false);
+    this.loopKeyDepthStack.push(loop.depth);
+    this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null);
+    this.loopParamStack.push(loop.param);
+    let body = "";
+    for (const item of items) {
+      this.staticLoopItemStack.push({ param: loop.param, item });
+      body += this.renderChildren(loop.children);
+      this.staticLoopItemStack.pop();
+      if (this.staticLoopBakeFailed) {
+        this.staticLoopBakeFailed = false;
+        this.state.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Loop array \`${loop.array.trim()}\` could not be fully unrolled — an expression in the loop body did not resolve against every item as the compile-time analysis expected.`,
+          loc: loop.loc ?? this.makeLoc(),
+          suggestion: {
+            message: "This indicates a bug in the Go adapter's static-loop unrolling (#2224) rather than an unsupported source pattern; please file a bug with a reproduction."
+          }
+        });
+        break;
+      }
+    }
+    this.loopParamStack.pop();
+    this.loopScalarItemStack.pop();
+    this.loopKeyDepthStack.pop();
+    this.loopWrapperStack.pop();
+    this.inLoop = false;
+    return `{{bfComment "loop:${loop.markerId}"}}${body}{{bfComment "/loop:${loop.markerId}"}}`;
+  }
   loopItemMarker(loop) {
     if (loop.bodyIsMultiRoot)
       return `{{bfComment "bf-loop-i"}}`;
@@ -5722,7 +6027,7 @@ ${children}`;
         const body = name.startsWith("aria-") ? `${name}="true"` : name;
         return `${preamble}{{if ${goCond}}}${body}{{end}}`;
       }
-      const parsed = value.parsed ?? parseExpression3(value.expr.trim());
+      const parsed = value.parsed ?? parseExpression4(value.expr.trim());
       if (parsed.kind === "conditional") {
         const undef = (e) => e.kind === "identifier" && (e.name === "undefined" || e.name === "null") || e.kind === "literal" && (e.value === null || e.value === undefined);
         const test = parsed.test;
@@ -5787,7 +6092,7 @@ ${children}`;
     if (!entries)
       return null;
     for (const e of entries) {
-      if (e.kind === "expr" && !isSupported(parseExpression3(e.expr)).supported)
+      if (e.kind === "expr" && !isSupported(parseExpression4(e.expr)).supported)
         return null;
     }
     return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:{{${this.convertExpressionToGo(e.expr)}}}`).join(";");
@@ -5797,6 +6102,8 @@ ${children}`;
     for (const attr of element.attrs) {
       if (attr.clientOnly)
         continue;
+      if (isDangerousInnerHtmlAttr(attr))
+        continue;
       let attrName;
       if (attr.name === "className")
         attrName = "class";

package/dist/conformance-pins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eAgI7B,CAAA"}
+{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eA+H7B,CAAA"}