@barefootjs/go-template 0.29.0 → 0.30.2

package/dist/build.js

@@ -1312,7 +1312,26 @@ function renderLoweringNode(ctx, node) {
 }
 
 // src/adapter/type/type-codegen.ts
-function typeInfoToGo(ctx, typeInfo, defaultValue) {
+function collapseLiteralUnion(typeInfo) {
+  if (typeInfo.kind !== "union" || !typeInfo.unionTypes || typeInfo.unionTypes.length === 0) {
+    return typeInfo;
+  }
+  const familyOf = (m) => {
+    if (m.kind !== "primitive")
+      return null;
+    return m.primitive === "string" || m.primitive === "number" || m.primitive === "boolean" ? m.primitive : null;
+  };
+  const first = familyOf(typeInfo.unionTypes[0]);
+  if (!first)
+    return typeInfo;
+  for (const m of typeInfo.unionTypes) {
+    if (familyOf(m) !== first)
+      return typeInfo;
+  }
+  return { kind: "primitive", raw: typeInfo.raw, primitive: first };
+}
+function typeInfoToGo(ctx, _typeInfo, defaultValue) {
+  const typeInfo = collapseLiteralUnion(_typeInfo);
   switch (typeInfo.kind) {
     case "primitive":
       switch (typeInfo.primitive) {
@@ -1482,7 +1501,8 @@ function nillableAwarePropRef(ctx, propName, expectedType) {
   }
   return fieldRef;
 }
-function convertInitialValue(ctx, value, typeInfo, propsParams, preParsed) {
+function convertInitialValue(ctx, value, _typeInfo, propsParams, preParsed) {
+  const typeInfo = collapseLiteralUnion(_typeInfo);
   const propRef = (propName2) => nillableAwarePropRef(ctx, propName2, typeInfo);
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
     if (propsParams?.some((p) => p.name === value)) {
@@ -2430,6 +2450,78 @@ function propsAccessNameFromParsed2(ctx, node) {
     return null;
   return node.property;
 }
+function collectPropsReadByCtorInit(body, propsObjectName, propNames) {
+  const found = new Set;
+  const visit = (e, bound) => {
+    switch (e.kind) {
+      case "identifier":
+        if (!propsObjectName && propNames.has(e.name) && !bound.has(e.name))
+          found.add(e.name);
+        return;
+      case "member":
+        if (propsObjectName && !e.computed && e.object.kind === "identifier" && e.object.name === propsObjectName) {
+          found.add(e.property);
+          return;
+        }
+        visit(e.object, bound);
+        return;
+      case "index-access":
+        visit(e.object, bound);
+        visit(e.index, bound);
+        return;
+      case "binary":
+      case "logical":
+        visit(e.left, bound);
+        visit(e.right, bound);
+        return;
+      case "unary":
+        visit(e.argument, bound);
+        return;
+      case "conditional":
+        visit(e.test, bound);
+        visit(e.consequent, bound);
+        visit(e.alternate, bound);
+        return;
+      case "call":
+        visit(e.callee, bound);
+        e.args.forEach((a) => visit(a, bound));
+        return;
+      case "template-literal":
+        for (const p of e.parts)
+          if (p.type === "expression")
+            visit(p.expr, bound);
+        return;
+      case "array-literal":
+        e.elements.forEach((el) => visit(el, bound));
+        return;
+      case "object-literal":
+        for (const p of e.properties)
+          visit(p.value, bound);
+        return;
+      case "array-method":
+        visit(e.object, bound);
+        e.args.forEach((a) => visit(a, bound));
+        if (e.method === "flat" && e.depthExpr)
+          visit(e.depthExpr, bound);
+        return;
+      case "arrow": {
+        const inner = e.params.length === 0 ? bound : new Set([...bound, ...e.params]);
+        visit(e.body, inner);
+        return;
+      }
+      case "literal":
+      case "regex":
+      case "unsupported":
+        return;
+      default: {
+        const _exhaustive = e;
+        return;
+      }
+    }
+  };
+  visit(body, new Set);
+  return found;
+}
 
 // src/adapter/spread/spread-codegen.ts
 import ts2 from "typescript";
@@ -3031,6 +3123,7 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.pendingChildrenDefines = [];
     this.primeCompileState(ir);
     this.state.stringValueNames = collectStringValueNames(ir);
+    this.recordDerivedFieldDeps(ir, new Set((ir.metadata.propsParams ?? []).map((p) => p.name)));
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
     }
@@ -3167,15 +3260,50 @@ ${scriptRegistrations}${templateBody}
     return `{{if .Scripts}}${registrations.join("")}{{end}}
 `;
   }
+  childDerivedFieldDeps = new Map;
+  childPropFieldNames = new Map;
+  childRepropsReady = new Map;
+  repropsOwner = new Map;
+  recordDerivedFieldDeps(ir, paramNames) {
+    const name = ir.metadata.componentName;
+    if (!name)
+      return;
+    const sourceOf = new Map((ir.metadata.propsParams ?? []).map((p) => [p.name, p.sourceName ?? p.name]));
+    const canonical = (local) => capitalizeFieldName(sourceOf.get(local) ?? local);
+    const propFieldNames = new Set([...paramNames].map(canonical));
+    const fieldNames = new Map;
+    for (const p of ir.metadata.propsParams ?? []) {
+      fieldNames.set(p.sourceName ?? p.name, capitalizeFieldName(p.name));
+    }
+    this.childPropFieldNames.set(name, fieldNames);
+    const deps = new Map;
+    const ctorInits = [
+      ...(ir.metadata.memos ?? []).map((m) => ({ field: m.name, init: m.parsed })),
+      ...(ir.metadata.signals ?? []).map((s) => ({ field: s.getter, init: s.parsed }))
+    ];
+    for (const { field, init } of ctorInits) {
+      if (propFieldNames.has(capitalizeFieldName(field)))
+        continue;
+      if (!init)
+        continue;
+      const read = collectPropsReadByCtorInit(init, ir.metadata.propsObjectName ?? null, paramNames);
+      if (read.size === 0)
+        continue;
+      deps.set(field, new Set([...read].map(canonical)));
+    }
+    if (deps.size > 0)
+      this.childDerivedFieldDeps.set(name, deps);
+  }
   registerChildComponentShape(ir) {
     const name = ir.metadata.componentName;
     if (!name)
       return;
-    const paramNames = new Set((ir.metadata.propsParams ?? []).map((p) => p.name));
+    const paramNames = new Set((ir.metadata.propsParams ?? []).map((p) => p.sourceName ?? p.name));
     const restPropsName = ir.metadata.restPropsName ?? null;
     const restBagField = restPropsName ? capitalizeFieldName(restPropsName) : null;
-    const mapTypedParamNames = new Set((ir.metadata.propsParams ?? []).filter((p) => p.optional && (p.type.kind === "object" || p.type.kind === "interface" && !!p.type.raw)).map((p) => p.name));
+    const mapTypedParamNames = new Set((ir.metadata.propsParams ?? []).filter((p) => p.optional && (p.type.kind === "object" || p.type.kind === "interface" && !!p.type.raw)).map((p) => p.sourceName ?? p.name));
     this.childComponentShapes.set(name, { paramNames, restBagField, mapTypedParamNames });
+    this.recordDerivedFieldDeps(ir, new Set((ir.metadata.propsParams ?? []).map((p) => p.name)));
     this.childContextConsumers.set(name, collectContextConsumers(ir.metadata));
   }
   contextFieldName(c) {
@@ -3244,8 +3372,86 @@ ${scriptRegistrations}${templateBody}
     this.state.needsStringsImport = false;
     this.generatePropsStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots);
     this.generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots, propTypeOverrides);
+    this.recordRepropsSpec(ir, componentName, nestedComponents, spreadSlots);
+    this.emitOwnedReprops(lines, componentName);
     return this.composeFileHeader(lines);
   }
+  recordRepropsSpec(ir, componentName, nestedComponents, spreadSlots) {
+    if (!this.childDerivedFieldDeps.has(componentName))
+      return;
+    const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
+    const params = (ir.metadata.propsParams ?? []).filter((p) => !nestedArrayFields.has(capitalizeFieldName(p.name)));
+    const takenInput = new Set((ir.metadata.propsParams ?? []).map((p) => capitalizeFieldName(p.name)));
+    const eligible = nestedComponents.every((n) => n.isDynamic && !n.isPropDerived) && spreadSlots.length === 0 && !ir.metadata.restPropsName && this.nonCollidingContextConsumers(takenInput).length === 0;
+    if (!eligible)
+      return;
+    this.childRepropsReady.set(componentName, {
+      params: params.map((p) => capitalizeFieldName(p.name)),
+      usesSearchParams: this.usesSearchParams(ir)
+    });
+  }
+  emitOwnedReprops(lines, owner) {
+    for (const [childName, ownerName] of this.repropsOwner) {
+      if (ownerName !== owner)
+        continue;
+      const spec = this.childRepropsReady.get(childName);
+      if (!spec)
+        continue;
+      this.emitRepropsRegistration(lines, childName, spec);
+    }
+  }
+  emitRepropsRegistration(lines, componentName, spec) {
+    const { params, usesSearchParams } = spec;
+    const inputTypeName = `${componentName}Input`;
+    const q = JSON.stringify(componentName);
+    lines.push(`// ${componentName} computes at least one field from an input prop when its`);
+    lines.push("// props are constructed, so a per-row override inside a composite loop row");
+    lines.push("// cannot be applied by patching fields — the derived field would keep the");
+    lines.push("// shared instance's one-shot value on every row (#2448). This rebuilder");
+    lines.push(`// re-runs New${componentName}Props with the row's overrides folded into the`);
+    lines.push("// Input; the parent calls it through bf_reprops.");
+    lines.push("func init() {");
+    lines.push(`	bf.RegisterReprops(${q}, func(base interface{}, kv ...interface{}) (interface{}, error) {`);
+    lines.push(`		b, ok := base.(${componentName}Props)`);
+    lines.push("\t\tif !ok {");
+    lines.push(`			return nil, bf.RepropsTypeError(${q}, base)`);
+    lines.push("\t\t}");
+    lines.push(`		in := ${inputTypeName}{`);
+    lines.push("\t\t\tScopeID: b.ScopeID,");
+    lines.push("\t\t\tBfParent: b.BfParent,");
+    lines.push("\t\t\tBfMount: b.BfMount,");
+    if (usesSearchParams)
+      lines.push("\t\t\tSearchParams: b.SearchParams,");
+    for (const field of params) {
+      lines.push(`			${field}: b.${field},`);
+    }
+    lines.push("\t\t}");
+    lines.push("\t\tfor i := 0; i < len(kv); i += 2 {");
+    lines.push("\t\t\tname, _ := kv[i].(string)");
+    lines.push("\t\t\tvar err error");
+    lines.push("\t\t\tswitch name {");
+    for (const field of params) {
+      lines.push(`			case ${JSON.stringify(field)}:`);
+      lines.push(`				err = bf.RepropsAssign(${q}, ${JSON.stringify(field)}, &in.${field}, kv[i+1])`);
+    }
+    lines.push("\t\t\tdefault:");
+    lines.push(`				err = bf.RepropsUnknownFieldError(${q}, name)`);
+    lines.push("\t\t\t}");
+    lines.push("\t\t\tif err != nil {");
+    lines.push("\t\t\t\treturn nil, err");
+    lines.push("\t\t\t}");
+    lines.push("\t\t}");
+    lines.push(`		p := New${componentName}Props(in)`);
+    lines.push("\t\t// Props-only state, absent from Input and therefore not rebuilt.");
+    lines.push("\t\tp.Scripts = b.Scripts");
+    lines.push("\t\tp.BfIsRoot = b.BfIsRoot");
+    lines.push("\t\tp.BfIsChild = b.BfIsChild");
+    lines.push("\t\tp.BfDataKey = b.BfDataKey");
+    lines.push("\t\treturn p, nil");
+    lines.push("\t})");
+    lines.push("}");
+    lines.push("");
+  }
   typeDefinitionToGo(td) {
     if (td.definition.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
       return `// ${td.name} is a string type.
@@ -3729,7 +3935,8 @@ ${goFields.join(`
         }
         if (jsxName.includes("-"))
           return;
-        lines.push(`			${capitalizeFieldName(jsxName)}: ${goValue},`);
+        const fieldName = this.childPropFieldNames.get(child.name)?.get(jsxName) ?? capitalizeFieldName(jsxName);
+        lines.push(`			${fieldName}: ${goValue},`);
       };
       for (const prop of child.props) {
         switch (prop.value.kind) {
@@ -5713,6 +5920,78 @@ ${goFields.join(`
   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));
   }
+  loopRowChildPropOverrides(comp) {
+    const childShape = this.childComponentShapes.get(comp.name);
+    const args = [];
+    let needsRebuild = false;
+    for (const prop of comp.props) {
+      if (prop.clientOnly)
+        continue;
+      if (prop.name === "key" || prop.name === "children")
+        continue;
+      if (prop.name.startsWith("on") && prop.name.length > 2)
+        continue;
+      if (prop.name.includes("-"))
+        continue;
+      if (childShape?.restBagField && !childShape.paramNames.has(prop.name))
+        continue;
+      if (prop.value.kind !== "expression")
+        continue;
+      const free = prop.freeIdentifiers;
+      if (!free || ![...free].some((name) => this.isLoopShadowedName(name)))
+        continue;
+      {
+        const derived = this.childDerivedFieldDeps.get(comp.name);
+        const overriddenField = capitalizeFieldName(prop.name);
+        const staleField = derived ? [...derived].find(([, deps]) => deps.has(overriddenField))?.[0] : undefined;
+        if (staleField && !this.childRepropsReady.has(comp.name)) {
+          this.state.errors.push({
+            code: "BF101",
+            severity: "error",
+            message: `Prop '${prop.name}' on <${comp.name}> nested inside a dynamic loop row is overridden per row, but <${comp.name}>'s '${staleField}' field is computed from '${prop.name}' when the shared instance is first constructed and won't recompute per row — it would keep the first row's value on every row.`,
+            loc: prop.loc,
+            suggestion: {
+              message: `Mark this loop position '@client' to render <${comp.name}> client-side, or compute '${staleField}' in the parent and pass it to <${comp.name}> as a plain prop instead of deriving it inside <${comp.name}>.`
+            }
+          });
+          continue;
+        }
+        if (staleField) {
+          needsRebuild = true;
+          if (!this.repropsOwner.has(comp.name)) {
+            this.repropsOwner.set(comp.name, this.state.componentName);
+          }
+        }
+      }
+      const exprOut = {};
+      const errorCountBefore = this.state.errors.length;
+      let go = this.convertExpressionToGo(prop.value.expr, exprOut, prop.value.parsed);
+      if (this.state.errors.length > errorCountBefore) {
+        for (let i = errorCountBefore;i < this.state.errors.length; i++) {
+          this.state.errors[i].loc = prop.loc;
+        }
+        continue;
+      }
+      const singlePartTemplateLiteral = exprOut.parsed?.kind === "template-literal" && exprOut.parsed.parts.length === 1 && exprOut.parsed.parts[0].type !== "string" && go.startsWith("{{") && go.endsWith("}}");
+      if (singlePartTemplateLiteral) {
+        go = go.slice(2, -2);
+      }
+      if (!singlePartTemplateLiteral && this.isTemplateFragment(go, exprOut.parsed?.kind)) {
+        this.state.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Prop '${prop.name}' on <${comp.name}> nested inside a dynamic loop row reads the row but can't be lowered to a Go template pipeline argument`,
+          loc: prop.loc
+        });
+        continue;
+      }
+      const fieldName = this.childPropFieldNames.get(comp.name)?.get(prop.name) ?? capitalizeFieldName(prop.name);
+      args.push(`${JSON.stringify(fieldName)} ${wrapIfMultiToken(go)}`);
+    }
+    if (args.length === 0)
+      return null;
+    return { args: args.join(" "), helper: needsRebuild ? "bf_reprops" : "bf_with_props" };
+  }
   resolveStaticRecordLiteralIndex(jsExpr) {
     const m = /^([A-Za-z_$][\w$]*)\[\s*(?:'([^']*)'|"([^"]*)")\s*\]$/.exec(jsExpr) ?? /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(jsExpr);
     if (!m)
@@ -6122,6 +6401,10 @@ ${goFields.join(`
     }
     this.inLoop = true;
     const addedLoopVars = [];
+    for (const d of loop.preamble?.declarations ?? []) {
+      this.loopVarRefCount.set(d.name, (this.loopVarRefCount.get(d.name) ?? 0) + 1);
+      addedLoopVars.push(d.name);
+    }
     let pushedBindingMap = false;
     if (supportableDestructure) {
       const built = this.buildDestructureBindingMap(loop, rangeValue);
@@ -6147,6 +6430,7 @@ ${goFields.join(`
     this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null);
     this.loopWrapperStack.push(!!loop.childComponent);
     this.loopKeyDepthStack.push(loop.depth);
+    const preambleAssignments = (loop.preamble?.declarations ?? []).map((d) => `{{$${d.name} := ${this.renderParsedExpr(d.valueParsed)}}}`).join("");
     const children = this.renderChildren(loop.children);
     this.loopKeyDepthStack.pop();
     this.loopWrapperStack.pop();
@@ -6181,9 +6465,9 @@ ${goFields.join(`
       } else {
         filterCond = "true";
       }
-      return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}{{if ${filterCond}}}${itemMarker}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
+      return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}{{if ${filterCond}}}${preambleAssignments}${itemMarker}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
     }
-    return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
+    return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${preambleAssignments}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
   }
   renderUnrolledStaticElementLoop(loop, items) {
     this.inLoop = true;
@@ -6282,8 +6566,10 @@ ${goFields.join(`
       }
     } else if (this.inLoop && comp.slotId) {
       const suffix = slotIdToFieldSuffix(comp.slotId);
+      const overrides = this.loopRowChildPropOverrides(comp);
       const loopBodyDefine = this.queueLoopBodyChildrenDefine(comp);
-      templateCall = loopBodyDefine ? `{{template "${comp.name}" (bf_with_children $.${comp.name}${suffix} (bf_tmpl "${loopBodyDefine}" .))}}` : `{{template "${comp.name}" $.${comp.name}${suffix}}}`;
+      const base = overrides ? overrides.helper === "bf_reprops" ? `(bf_reprops ${JSON.stringify(comp.name)} $.${comp.name}${suffix} ${overrides.args})` : `(bf_with_props $.${comp.name}${suffix} ${overrides.args})` : `$.${comp.name}${suffix}`;
+      templateCall = loopBodyDefine ? `{{template "${comp.name}" (bf_with_children ${base} (bf_tmpl "${loopBodyDefine}" .))}}` : `{{template "${comp.name}" ${base}}}`;
     } else if (this.inLoop) {
       templateCall = `{{template "${comp.name}" .}}`;
     } else if (comp.slotId) {

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,eAqL7B,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,eAgL7B,CAAA"}