@barefootjs/go-template 0.7.0 → 0.9.0

package/dist/adapter/index.js

@@ -32,7 +32,10 @@ import {
   identifierPath,
   emitParsedExpr,
   emitIRNode,
-  emitAttrValue
+  emitAttrValue,
+  augmentInheritedPropAccesses,
+  parseRecordIndexAccess,
+  collectContextConsumers
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
 function wrapIfMultiToken(rendered) {
@@ -117,7 +120,13 @@ class GoTemplateAdapter extends BaseAdapter {
   localStructFields = new Map;
   synthStructTypes = new Map;
   usesHtmlTemplate = false;
+  usesFmt = false;
+  childComponentShapes = new Map;
   moduleStringConsts = new Map;
+  localConstants = [];
+  contextConsumers = [];
+  childContextConsumers = new Map;
+  nillablePropNames = new Set;
   constructor(options = {}) {
     super();
     this.options = {
@@ -133,6 +142,10 @@ class GoTemplateAdapter extends BaseAdapter {
     this.propsObjectName = ir.metadata.propsObjectName;
     this.restPropsName = ir.metadata.restPropsName ?? null;
     this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
+    this.localConstants = ir.metadata.localConstants ?? [];
+    this.contextConsumers = collectContextConsumers(ir.metadata);
+    augmentInheritedPropAccesses(ir);
+    this.nillablePropNames = this.collectNillablePropNames(ir);
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
     }
@@ -345,8 +358,46 @@ ${scriptRegistrations}${templateBody}
     return `{{if .Scripts}}${registrations.join("")}{{end}}
 `;
   }
+  registerChildComponentShape(ir) {
+    const name = ir.metadata.componentName;
+    if (!name)
+      return;
+    const paramNames = new Set((ir.metadata.propsParams ?? []).map((p) => p.name));
+    const restPropsName = ir.metadata.restPropsName ?? null;
+    const restBagField = restPropsName ? this.capitalizeFieldName(restPropsName) : null;
+    this.childComponentShapes.set(name, { paramNames, restBagField });
+    this.childContextConsumers.set(name, collectContextConsumers(ir.metadata));
+  }
+  contextFieldName(c) {
+    return this.capitalizeFieldName(c.localName);
+  }
+  contextConsumerGoType(c) {
+    if (typeof c.defaultValue === "number")
+      return "int";
+    if (typeof c.defaultValue === "boolean")
+      return "bool";
+    return "string";
+  }
+  contextConsumerGoDefault(c) {
+    if (typeof c.defaultValue === "number")
+      return String(c.defaultValue);
+    if (typeof c.defaultValue === "boolean")
+      return String(c.defaultValue);
+    if (typeof c.defaultValue === "string")
+      return `"${this.escapeGoString(c.defaultValue)}"`;
+    return '""';
+  }
+  nonCollidingContextConsumers(taken) {
+    return this.contextConsumers.filter((c) => !taken.has(this.contextFieldName(c)));
+  }
   generateTypes(ir) {
     this.usesHtmlTemplate = false;
+    this.usesFmt = false;
+    this.propsObjectName = ir.metadata.propsObjectName;
+    augmentInheritedPropAccesses(ir);
+    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
+    this.localConstants = ir.metadata.localConstants ?? [];
+    this.contextConsumers = collectContextConsumers(ir.metadata);
     const lines = [];
     const componentName = ir.metadata.componentName;
     this.localTypeNames = new Set;
@@ -408,6 +459,8 @@ ${goFields.join(`
     header.push(`package ${this.options.packageName}`);
     header.push("");
     header.push("import (");
+    if (this.usesFmt)
+      header.push('\t"fmt"');
     if (this.usesHtmlTemplate)
       header.push('\t"html/template"');
     header.push('\t"math/rand"');
@@ -568,6 +621,19 @@ ${goFields.join(`
     }
     return overrides;
   }
+  resolvePropGoType(param, propTypeOverrides) {
+    return propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue);
+  }
+  collectNillablePropNames(ir) {
+    const propTypeOverrides = this.buildPropTypeOverrides(ir);
+    const nillable = new Set;
+    for (const param of ir.metadata.propsParams) {
+      if (this.resolvePropGoType(param, propTypeOverrides) === "interface{}") {
+        nillable.add(param.name);
+      }
+    }
+    return nillable;
+  }
   generateInputStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots) {
     const inputTypeName = `${componentName}Input`;
     lines.push(`// ${inputTypeName} is the user-facing input type.`);
@@ -581,12 +647,16 @@ ${goFields.join(`
       const fieldName = this.capitalizeFieldName(param.name);
       if (nestedArrayFields.has(fieldName))
         continue;
-      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue);
+      const goType = this.resolvePropGoType(param, propTypeOverrides);
       lines.push(`	${fieldName} ${goType}`);
     }
     for (const nested of inputNested) {
       lines.push(`	${nested.name}s []${nested.name}Input`);
     }
+    const takenInput = new Set(ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)));
+    for (const c of this.nonCollidingContextConsumers(takenInput)) {
+      lines.push(`	${this.contextFieldName(c)} ${this.contextConsumerGoType(c)}`);
+    }
     const restPropsName = ir.metadata.restPropsName;
     if (restPropsName) {
       const seen = new Set;
@@ -620,7 +690,7 @@ ${goFields.join(`
       const fieldName = this.capitalizeFieldName(param.name);
       if (nestedArrayFields.has(fieldName))
         continue;
-      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue);
+      const goType = this.resolvePropGoType(param, propTypeOverrides);
       const jsonTag = this.toJsonTag(param.name);
       lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
       propFieldNames.add(fieldName);
@@ -664,6 +734,15 @@ ${goFields.join(`
       const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap);
       lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
     }
+    const takenProps = new Set([
+      ...ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)),
+      ...ir.metadata.signals.map((s) => this.capitalizeFieldName(s.getter)),
+      ...ir.metadata.memos.map((m) => this.capitalizeFieldName(m.name))
+    ]);
+    for (const c of this.nonCollidingContextConsumers(takenProps)) {
+      const jsonTag = this.toJsonTag(c.localName);
+      lines.push(`	${this.contextFieldName(c)} ${this.contextConsumerGoType(c)} \`json:"${jsonTag}"\``);
+    }
     for (const nested of nestedComponents) {
       if (nested.isDynamic && !nested.isPropDerived) {
         lines.push(`	${nested.name}s []${nested.name}Props \`json:"-"\``);
@@ -773,25 +852,55 @@ ${goFields.join(`
       const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
       lines.push(`		${nested.name}s: ${varName},`);
     }
+    const memoPropsParamMap = new Map(ir.metadata.propsParams.map((p) => [p.name, p]));
     for (const memo of ir.metadata.memos) {
       const fieldName = this.capitalizeFieldName(memo.name);
-      const memoValue = this.computeMemoInitialValue(memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars);
+      const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap);
+      const memoValue = this.computeMemoInitialValue(memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType);
       lines.push(`		${fieldName}: ${memoValue},`);
     }
+    const takenInit = new Set([
+      ...ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)),
+      ...ir.metadata.signals.map((s) => this.capitalizeFieldName(s.getter)),
+      ...ir.metadata.memos.map((m) => this.capitalizeFieldName(m.name))
+    ]);
+    for (const c of this.nonCollidingContextConsumers(takenInit)) {
+      const field = this.contextFieldName(c);
+      const def = this.contextConsumerGoDefault(c);
+      const defaulted = c.defaultValue === null || def === '""' || def === "0" || def === "false" ? `in.${field}` : this.applyGoFallback(`in.${field}`, def);
+      lines.push(`		${field}: ${defaulted},`);
+    }
     const staticChildren = this.collectStaticChildInstances(ir.root);
     for (const child of staticChildren) {
       lines.push(`		${child.fieldName}: New${child.name}Props(${child.name}Input{`);
       lines.push(`			ScopeID: scopeID + "_${child.slotId}",`);
       lines.push(`			BfParent: scopeID,`);
       lines.push(`			BfMount: "${child.slotId}",`);
+      if (child.contextBindings) {
+        for (const consumer of this.childContextConsumers.get(child.name) ?? []) {
+          const goVal = child.contextBindings.get(consumer.contextName);
+          if (goVal !== undefined) {
+            lines.push(`			${this.contextFieldName(consumer)}: ${goVal},`);
+          }
+        }
+      }
+      const childShape = this.childComponentShapes.get(child.name);
+      const restBagEntries = [];
+      const emitChildField = (jsxName, goValue) => {
+        if (childShape && childShape.restBagField && !childShape.paramNames.has(jsxName)) {
+          restBagEntries.push(`${JSON.stringify(jsxName)}: ${goValue}`);
+          return;
+        }
+        lines.push(`			${this.capitalizeFieldName(jsxName)}: ${goValue},`);
+      };
       for (const prop of child.props) {
         switch (prop.value.kind) {
           case "literal":
-            lines.push(`			${this.capitalizeFieldName(prop.name)}: ${this.goLiteral(prop.value.value)},`);
+            emitChildField(prop.name, this.goLiteral(prop.value.value));
             break;
           case "boolean-shorthand":
           case "boolean-attr":
-            lines.push(`			${this.capitalizeFieldName(prop.name)}: true,`);
+            emitChildField(prop.name, "true");
             break;
           case "expression":
           case "spread":
@@ -800,7 +909,7 @@ ${goFields.join(`
             if (parts) {
               const goExpr = this.templatePartsToGoCode(parts, ir.metadata.propsParams);
               if (goExpr !== null) {
-                lines.push(`			${this.capitalizeFieldName(prop.name)}: ${goExpr},`);
+                emitChildField(prop.name, goExpr);
                 break;
               }
             }
@@ -809,7 +918,7 @@ ${goFields.join(`
               break;
             const resolvedValue = this.resolveDynamicPropValue(exprText, ir.metadata.signals, ir.metadata.memos, ir.metadata.propsParams);
             if (resolvedValue !== null) {
-              lines.push(`			${this.capitalizeFieldName(prop.name)}: ${resolvedValue},`);
+              emitChildField(prop.name, resolvedValue);
             }
             break;
           }
@@ -817,6 +926,9 @@ ${goFields.join(`
             break;
         }
       }
+      if (childShape?.restBagField && restBagEntries.length > 0) {
+        lines.push(`			${childShape.restBagField}: map[string]any{${restBagEntries.join(", ")}},`);
+      }
       if (child.childrenText !== null) {
         lines.push(`			Children: ${JSON.stringify(child.childrenText)},`);
       } else if (child.childrenHtml !== null) {
@@ -887,7 +999,7 @@ ${goFields.join(`
   }
   collectStaticChildInstances(node) {
     const result = [];
-    this.collectStaticChildInstancesRecursive(node, result, false);
+    this.collectStaticChildInstancesRecursive(node, result, false, new Map);
     return result;
   }
   extractTextChildren(children) {
@@ -911,12 +1023,12 @@ ${goFields.join(`
       return null;
     return html;
   }
-  collectStaticChildInstancesRecursive(node, result, inLoop) {
+  collectStaticChildInstancesRecursive(node, result, inLoop, providerCtx) {
     if (node.type === "component") {
       const comp = node;
       if (comp.dynamicTag) {
         for (const child of comp.children) {
-          this.collectStaticChildInstancesRecursive(child, result, inLoop);
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
         }
         return;
       }
@@ -928,48 +1040,65 @@ ${goFields.join(`
           props: comp.props,
           fieldName: `${comp.name}${suffix}`,
           childrenText: this.extractTextChildren(comp.children),
-          childrenHtml: this.extractHtmlChildren(comp.children)
+          childrenHtml: this.extractHtmlChildren(comp.children),
+          contextBindings: providerCtx.size > 0 ? providerCtx : undefined
         });
       }
       if (comp.name === "Portal" && comp.children) {
         for (const child of comp.children) {
-          this.collectStaticChildInstancesRecursive(child, result, inLoop);
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
         }
       }
     } else if (node.type === "loop") {
       const loop = node;
       for (const child of loop.children) {
-        this.collectStaticChildInstancesRecursive(child, result, true);
+        this.collectStaticChildInstancesRecursive(child, result, true, providerCtx);
       }
     } else if (node.type === "element") {
       const element = node;
       for (const child of element.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
       }
     } else if (node.type === "fragment") {
       const fragment = node;
       for (const child of fragment.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
       }
     } else if (node.type === "conditional") {
       const cond = node;
-      this.collectStaticChildInstancesRecursive(cond.whenTrue, result, inLoop);
+      this.collectStaticChildInstancesRecursive(cond.whenTrue, result, inLoop, providerCtx);
       if (cond.whenFalse) {
-        this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop);
+        this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop, providerCtx);
       }
     } else if (node.type === "provider") {
       const p = node;
+      const childCtx = this.extendProviderContext(providerCtx, p);
       for (const child of p.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, childCtx);
       }
     } else if (node.type === "async") {
       const a = node;
-      this.collectStaticChildInstancesRecursive(a.fallback, result, inLoop);
+      this.collectStaticChildInstancesRecursive(a.fallback, result, inLoop, providerCtx);
       for (const child of a.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
       }
     }
   }
+  extendProviderContext(current, p) {
+    const v = p.valueProp?.value;
+    if (!v || v.kind !== "literal")
+      return current;
+    let goLit = null;
+    if (typeof v.value === "string")
+      goLit = `"${this.escapeGoString(v.value)}"`;
+    else if (typeof v.value === "number" || typeof v.value === "boolean")
+      goLit = String(v.value);
+    if (goLit === null)
+      return current;
+    const next = new Map(current);
+    next.set(p.contextName, goLit);
+    return next;
+  }
   collectSpreadSlots(node) {
     const result = [];
     this.collectSpreadSlotsRecursive(node, result);
@@ -1094,6 +1223,9 @@ ${goFields.join(`
   }
   buildSpreadInitializer(spreadExpr, ir) {
     const trimmed = spreadExpr.trim();
+    const conditional = this.buildConditionalSpreadInitializer(trimmed, ir);
+    if (conditional !== undefined)
+      return conditional;
     const callMatch = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*\(\s*\)$/.exec(trimmed);
     if (callMatch) {
       const getterName = callMatch[1];
@@ -1117,9 +1249,127 @@ ${goFields.join(`
       if (ir.metadata.restPropsName === trimmed) {
         return `in.${this.capitalizeFieldName(trimmed)}`;
       }
+      const localConst = (ir.metadata.localConstants ?? []).find((c) => c.name === trimmed && !c.isModule);
+      if (localConst?.value !== undefined) {
+        const initTrimmed = localConst.value.trim();
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(initTrimmed)) {
+          const resolved = this.buildConditionalSpreadInitializer(initTrimmed, ir);
+          if (resolved)
+            return resolved;
+          if (resolved === null)
+            return null;
+        }
+      }
     }
     return null;
   }
+  buildConditionalSpreadInitializer(spreadExpr, ir) {
+    const expr = this.parseLiteralExpression(spreadExpr);
+    if (!expr || !ts.isConditionalExpression(expr))
+      return;
+    const whenTrue = this.unwrapParens(expr.whenTrue);
+    const whenFalse = this.unwrapParens(expr.whenFalse);
+    if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
+      return;
+    }
+    const goCond = this.conditionToGoBool(expr.condition, ir);
+    if (goCond === null)
+      return null;
+    const trueMap = this.objectLiteralToGoSpreadMap(whenTrue, ir);
+    const falseMap = this.objectLiteralToGoSpreadMap(whenFalse, ir);
+    if (trueMap === null || falseMap === null)
+      return null;
+    return `func() map[string]any {
+` + `		if ${goCond} {
+` + `			return ${trueMap}
+` + `		}
+` + `		return ${falseMap}
+` + `	}()`;
+  }
+  unwrapParens(node) {
+    let e = node;
+    while (ts.isParenthesizedExpression(e))
+      e = e.expression;
+    return e;
+  }
+  conditionToGoBool(condition, ir) {
+    let node = this.unwrapParens(condition);
+    let negate = false;
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
+      negate = true;
+      node = this.unwrapParens(node.operand);
+    }
+    if (!ts.isIdentifier(node))
+      return null;
+    const param = ir.metadata.propsParams.find((p) => p.name === node.text);
+    if (!param)
+      return null;
+    const field = `in.${this.capitalizeFieldName(param.name)}`;
+    const prim = param.type.kind === "primitive" ? param.type.primitive : undefined;
+    let truthy;
+    if (prim === "boolean") {
+      truthy = field;
+    } else if (prim === "number") {
+      truthy = `${field} != 0`;
+    } else if (prim === "string") {
+      truthy = `${field} != ""`;
+    } else {
+      truthy = `bf.Truthy(${field})`;
+    }
+    if (!negate)
+      return truthy;
+    if (prim === "boolean")
+      return `!${field}`;
+    if (prim === "number")
+      return `${field} == 0`;
+    if (prim === "string")
+      return `${field} == ""`;
+    return `!bf.Truthy(${field})`;
+  }
+  objectLiteralToGoSpreadMap(obj, ir) {
+    const entries = [];
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop))
+        return null;
+      let key;
+      if (ts.isIdentifier(prop.name)) {
+        key = prop.name.text;
+      } else if (ts.isStringLiteral(prop.name) || ts.isNoSubstitutionTemplateLiteral(prop.name)) {
+        key = prop.name.text;
+      } else {
+        return null;
+      }
+      const val = this.unwrapParens(prop.initializer);
+      let goVal;
+      if (ts.isStringLiteral(val) || ts.isNoSubstitutionTemplateLiteral(val)) {
+        goVal = JSON.stringify(val.text);
+      } else if (ts.isIdentifier(val)) {
+        const param = ir.metadata.propsParams.find((p) => p.name === val.text);
+        if (!param)
+          return null;
+        goVal = `in.${this.capitalizeFieldName(param.name)}`;
+      } else {
+        const indexed = this.recordIndexAccessToGoMap(val, ir);
+        if (indexed === null)
+          return null;
+        goVal = indexed;
+      }
+      entries.push(`${JSON.stringify(key)}: ${goVal}`);
+    }
+    return `map[string]any{${entries.join(", ")}}`;
+  }
+  recordIndexAccessToGoMap(val, ir) {
+    const parsed = parseRecordIndexAccess(val, ir.metadata.localConstants ?? [], ir.metadata.propsParams);
+    if (!parsed)
+      return null;
+    const entries = parsed.entries.map((e) => {
+      const mapVal = e.value.kind === "number" ? e.value.text : JSON.stringify(e.value.text);
+      return `${JSON.stringify(e.key)}: ${mapVal}`;
+    });
+    this.usesFmt = true;
+    const field = `in.${this.capitalizeFieldName(parsed.indexPropName)}`;
+    return `map[string]any{${entries.join(", ")}}[fmt.Sprint(${field})]`;
+  }
   convertInitialValue(value, typeInfo, propsParams) {
     if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
       if (propsParams?.some((p) => p.name === value)) {
@@ -1360,7 +1610,142 @@ ${goFields.join(`
     }
     return null;
   }
-  computeMemoInitialValue(memo, signals, propsParams, propFallbackVars = GoTemplateAdapter.EMPTY_PROP_FALLBACK_VARS) {
+  computeTemplateLiteralMemoInitialValue(computation, propsParams) {
+    const sf = ts.createSourceFile("__memo.ts", `const __x = (${computation});`, ts.ScriptTarget.Latest, false);
+    const stmt = sf.statements[0];
+    if (!stmt || !ts.isVariableStatement(stmt))
+      return null;
+    let init = stmt.declarationList.declarations[0]?.initializer;
+    while (init && ts.isParenthesizedExpression(init))
+      init = init.expression;
+    if (!init || !ts.isArrowFunction(init))
+      return null;
+    let body = init.body;
+    while (ts.isParenthesizedExpression(body)) {
+      body = body.expression;
+    }
+    const localKeyBindings = new Map;
+    if (ts.isBlock(body)) {
+      let returned = null;
+      for (const s of body.statements) {
+        if (ts.isVariableStatement(s)) {
+          for (const d of s.declarationList.declarations) {
+            if (!ts.isIdentifier(d.name) || !d.initializer)
+              continue;
+            const binding = this.parseLocalKeyBinding(d.initializer);
+            if (binding)
+              localKeyBindings.set(d.name.text, binding);
+          }
+        } else if (ts.isReturnStatement(s) && s.expression) {
+          returned = s.expression;
+        } else if (ts.isExpressionStatement(s) || ts.isEmptyStatement(s)) {} else {
+          return null;
+        }
+      }
+      if (!returned)
+        return null;
+      body = returned;
+      while (ts.isParenthesizedExpression(body)) {
+        body = body.expression;
+      }
+    }
+    if (!ts.isTemplateExpression(body) && !ts.isNoSubstitutionTemplateLiteral(body)) {
+      return null;
+    }
+    const propNames = new Set(propsParams.map((p) => p.name));
+    const escGo = (s) => `"${this.escapeGoString(s)}"`;
+    const segments = [];
+    if (ts.isNoSubstitutionTemplateLiteral(body)) {
+      return escGo(body.text);
+    }
+    if (body.head.text)
+      segments.push(escGo(body.head.text));
+    for (const span of body.templateSpans) {
+      const resolved = this.resolveTemplateInterpolation(span.expression, propNames, localKeyBindings);
+      if (resolved === null)
+        return null;
+      segments.push(resolved);
+      if (span.literal.text)
+        segments.push(escGo(span.literal.text));
+    }
+    if (segments.length === 0)
+      return '""';
+    return segments.join(" + ");
+  }
+  resolveTemplateInterpolation(expr, propNames, localKeyBindings = new Map) {
+    let node = expr;
+    while (ts.isParenthesizedExpression(node))
+      node = node.expression;
+    if (ts.isIdentifier(node)) {
+      const inlined = this.resolveModuleStringConst(node.text);
+      if (inlined !== null)
+        return inlined;
+      return null;
+    }
+    if (ts.isElementAccessExpression(node)) {
+      const indexed = this.recordIndexInterpolationToGo(node, propNames, localKeyBindings);
+      if (indexed !== null)
+        return indexed;
+      return null;
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+      const right = node.right;
+      const isEmptyStr = (ts.isStringLiteral(right) || ts.isNoSubstitutionTemplateLiteral(right)) && right.text === "";
+      const propName2 = this.propsAccessName(node.left);
+      if (propName2 && propNames.has(propName2) && isEmptyStr) {
+        return `in.${this.capitalizeFieldName(propName2)}`;
+      }
+      return null;
+    }
+    const propName = this.propsAccessName(node);
+    if (propName && propNames.has(propName)) {
+      return `in.${this.capitalizeFieldName(propName)}`;
+    }
+    return null;
+  }
+  parseLocalKeyBinding(init) {
+    let node = init;
+    while (ts.isParenthesizedExpression(node))
+      node = node.expression;
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+      const propName2 = this.propsAccessName(node.left);
+      const right = node.right;
+      if (propName2 && (ts.isStringLiteral(right) || ts.isNoSubstitutionTemplateLiteral(right))) {
+        return { propName: propName2, defaultLiteral: right.text };
+      }
+      return null;
+    }
+    const propName = this.propsAccessName(node);
+    if (propName)
+      return { propName };
+    return null;
+  }
+  recordIndexInterpolationToGo(node, propNames, localKeyBindings) {
+    const parsed = parseRecordIndexAccess(node, this.localConstants ?? [], [...propNames].map((name) => ({ name })), (name) => localKeyBindings.get(name) ?? null);
+    if (!parsed)
+      return null;
+    const goVal = (v) => v.kind === "number" ? v.text : JSON.stringify(v.text);
+    const entries = parsed.entries.map((e) => `${JSON.stringify(e.key)}: ${goVal(e.value)}`);
+    if (parsed.defaultKey !== undefined) {
+      const def = parsed.entries.find((e) => e.key === parsed.defaultKey);
+      if (def)
+        entries.unshift(`"": ${goVal(def.value)}`);
+    }
+    const allString = parsed.entries.every((e) => e.value.kind === "string");
+    const mapType = allString ? "map[string]string" : "map[string]any";
+    this.usesFmt = true;
+    return `${mapType}{${entries.join(", ")}}[fmt.Sprint(in.${this.capitalizeFieldName(parsed.indexPropName)})]`;
+  }
+  propsAccessName(node) {
+    if (!ts.isPropertyAccessExpression(node))
+      return null;
+    if (!ts.isIdentifier(node.expression))
+      return null;
+    if (!this.propsObjectName || node.expression.text !== this.propsObjectName)
+      return null;
+    return node.name.text;
+  }
+  computeMemoInitialValue(memo, signals, propsParams, propFallbackVars = GoTemplateAdapter.EMPTY_PROP_FALLBACK_VARS, goType) {
     const computation = memo.computation;
     const propRef = (propName) => {
       const hoisted = propFallbackVars.get(propName);
@@ -1368,6 +1753,9 @@ ${goFields.join(`
         return hoisted.varName;
       return `in.${this.capitalizeFieldName(propName)}`;
     };
+    const tmplMemo = this.computeTemplateLiteralMemoInitialValue(computation, propsParams);
+    if (tmplMemo !== null)
+      return tmplMemo;
     const arithmeticMatch = computation.match(/\(\)\s*=>\s*(\w+)\(\)\s*([*+\-/])\s*(\d+)/);
     if (arithmeticMatch) {
       const [, depName, operator, operand] = arithmeticMatch;
@@ -1387,8 +1775,8 @@ ${goFields.join(`
           return `${hoisted.varName} ${operator} ${operand}`;
         const fieldName = this.capitalizeFieldName(propName);
         if (param.type) {
-          const goType = this.typeInfoToGo(param.type, param.defaultValue);
-          if (goType === "interface{}")
+          const goType2 = this.typeInfoToGo(param.type, param.defaultValue);
+          if (goType2 === "interface{}")
             return `in.${fieldName}.(int) ${operator} ${operand}`;
         }
         return `in.${fieldName} ${operator} ${operand}`;
@@ -1417,8 +1805,8 @@ ${goFields.join(`
       if (param) {
         const fieldName = this.capitalizeFieldName(varName);
         if (param.type) {
-          const goType = this.typeInfoToGo(param.type, param.defaultValue);
-          if (goType === "interface{}")
+          const goType2 = this.typeInfoToGo(param.type, param.defaultValue);
+          if (goType2 === "interface{}")
             return `in.${fieldName}.(int) ${operator} ${operand}`;
         }
         return `in.${fieldName} ${operator} ${operand}`;
@@ -1432,9 +1820,40 @@ ${goFields.join(`
         return `in.${this.capitalizeFieldName(varName)}`;
       }
     }
+    if (goType === "bool")
+      return "false";
+    if (goType === "string")
+      return '""';
     return "0";
   }
+  isTemplateLiteralMemo(computation) {
+    const sf = ts.createSourceFile("__memo.ts", `const __x = (${computation});`, ts.ScriptTarget.Latest, false);
+    const stmt = sf.statements[0];
+    if (!stmt || !ts.isVariableStatement(stmt))
+      return false;
+    let init = stmt.declarationList.declarations[0]?.initializer;
+    while (init && ts.isParenthesizedExpression(init))
+      init = init.expression;
+    if (!init || !ts.isArrowFunction(init))
+      return false;
+    let body = init.body;
+    while (ts.isParenthesizedExpression(body)) {
+      body = body.expression;
+    }
+    if (ts.isBlock(body)) {
+      const ret = body.statements.find(ts.isReturnStatement);
+      if (!ret || !ret.expression)
+        return false;
+      body = ret.expression;
+      while (ts.isParenthesizedExpression(body)) {
+        body = body.expression;
+      }
+    }
+    return ts.isTemplateExpression(body) || ts.isNoSubstitutionTemplateLiteral(body);
+  }
   inferMemoType(memo, signals, propsParamMap) {
+    if (this.isTemplateLiteralMemo(memo.computation))
+      return "string";
     if (memo.computation.includes("*") || memo.computation.includes("/") || memo.computation.includes("+") || memo.computation.includes("-")) {
       for (const dep of memo.deps) {
         const signal = signals.find((s) => s.getter === dep);
@@ -1458,8 +1877,39 @@ ${goFields.join(`
         }
       }
     }
+    if (this.typeInfoToGo(memo.type) === "interface{}" && this.isBooleanMemo(memo, signals, propsParamMap)) {
+      return "bool";
+    }
     return this.typeInfoToGo(memo.type);
   }
+  isBooleanMemo(memo, signals, propsParamMap) {
+    const c = memo.computation;
+    if (/(!==|===|!=(?!=)|==(?!=))/.test(c))
+      return true;
+    if (/=>\s*!/.test(c))
+      return true;
+    const isBoolGetter = (name) => {
+      const sig = signals.find((s) => s.getter === name);
+      if (sig) {
+        if (this.typeInfoToGo(sig.type) === "bool")
+          return true;
+        if (/\?\?\s*(true|false)\b/.test(sig.initialValue))
+          return true;
+        const propName = this.extractPropNameFromInitialValue(sig.initialValue) ?? sig.initialValue;
+        const prop2 = propsParamMap.get(propName);
+        if (prop2 && this.typeInfoToGo(prop2.type, prop2.defaultValue) === "bool")
+          return true;
+        return false;
+      }
+      const prop = propsParamMap.get(name);
+      return !!prop && this.typeInfoToGo(prop.type, prop.defaultValue) === "bool";
+    };
+    const ternary = c.match(/=>\s*\w+\(\)\s*\?\s*(\w+)\(\)\s*:\s*(\w+)\(\)/);
+    if (ternary) {
+      return isBoolGetter(ternary[1]) && isBoolGetter(ternary[2]);
+    }
+    return false;
+  }
   inferTypeFromValue(value) {
     if (value === "true" || value === "false")
       return "bool";
@@ -1807,8 +2257,42 @@ ${goFields.join(`
     if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
       return init.text;
     }
+    const joined = this.evalStringArrayJoin(init);
+    if (joined !== null)
+      return joined;
     return null;
   }
+  evalStringArrayJoin(node) {
+    if (!ts.isCallExpression(node))
+      return null;
+    const callee = node.expression;
+    if (!ts.isPropertyAccessExpression(callee))
+      return null;
+    if (callee.name.text !== "join")
+      return null;
+    let recv = callee.expression;
+    while (ts.isParenthesizedExpression(recv))
+      recv = recv.expression;
+    if (!ts.isArrayLiteralExpression(recv))
+      return null;
+    const parts = [];
+    for (const el of recv.elements) {
+      if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
+        parts.push(el.text);
+      } else {
+        return null;
+      }
+    }
+    let sep = ",";
+    if (node.arguments.length >= 1) {
+      const arg = node.arguments[0];
+      if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg))
+        sep = arg.text;
+      else
+        return null;
+    }
+    return parts.join(sep);
+  }
   resolveModuleStringConst(name) {
     if (this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name) {
       return null;
@@ -2968,6 +3452,12 @@ ${children}`;
       if (parsed.kind === "conditional" || parsed.kind === "template-literal") {
         return `${name}="${this.renderParsedExpr(parsed)}"`;
       }
+      const bareId = value.expr.trim();
+      const propName = this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`) ? bareId.slice(this.propsObjectName.length + 1) : bareId;
+      if (/^[A-Za-z_$][\w$]*$/.test(propName) && this.nillablePropNames.has(propName)) {
+        const field = `.${this.capitalizeFieldName(propName)}`;
+        return `{{if ne ${field} nil}}${name}="{{${this.convertExpressionToGo(value.expr)}}}"{{end}}`;
+      }
       return `${name}="{{${this.convertExpressionToGo(value.expr)}}}"`;
     },
     emitBooleanAttr: (_value, name) => name,