@barefootjs/go-template 0.5.0 → 0.5.2

package/dist/index.js

@@ -90,6 +90,8 @@ class GoTemplateAdapter extends BaseAdapter {
   templateVarCounter = 0;
   localTypeNames = new Set;
   localTypeAliases = new Map;
+  localStructFields = new Map;
+  synthStructTypes = new Map;
   usesHtmlTemplate = false;
   constructor(options = {}) {
     super();
@@ -323,6 +325,7 @@ ${scriptRegistrations}${templateBody}
     const componentName = ir.metadata.componentName;
     this.localTypeNames = new Set;
     this.localTypeAliases = new Map;
+    this.localStructFields = new Map;
     for (const td of ir.metadata.typeDefinitions) {
       if (td.name === "Props" || td.name === `${componentName}Props`)
         continue;
@@ -331,6 +334,11 @@ ${scriptRegistrations}${templateBody}
       this.localTypeNames.add(td.name);
       if (td.definition.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
         this.localTypeAliases.set(td.name, "string");
+      } else {
+        const fields = this.structFieldsFor(td);
+        if (fields.length > 0) {
+          this.localStructFields.set(td.name, new Map(fields.map((f) => [f.tsName, f.goName])));
+        }
       }
     }
     for (const td of ir.metadata.typeDefinitions) {
@@ -344,6 +352,26 @@ ${scriptRegistrations}${templateBody}
         lines.push("");
       }
     }
+    this.synthStructTypes = new Map;
+    for (const signal of ir.metadata.signals) {
+      const synth = this.synthesizeStructFromSignal(signal, componentName);
+      if (!synth)
+        continue;
+      this.localTypeNames.add(synth.name);
+      this.localStructFields.set(synth.name, new Map(synth.fields.map((f) => [f.tsName, f.goName])));
+      this.synthStructTypes.set(signal.getter, {
+        kind: "array",
+        raw: `${synth.name}[]`,
+        elementType: { kind: "interface", raw: synth.name }
+      });
+      const goFields = synth.fields.map((f) => `	${f.goName} ${f.goType} \`json:"${this.toJsonTag(f.tsName)}"\``);
+      lines.push(`// ${synth.name} is a synthesised element type for the ${signal.getter} signal.`);
+      lines.push(`type ${synth.name} struct {
+${goFields.join(`
+`)}
+}`);
+      lines.push("");
+    }
     const nestedComponents = this.findNestedComponents(ir.root);
     const propTypeOverrides = this.buildPropTypeOverrides(ir);
     const spreadSlots = this.collectSpreadSlots(ir.root);
@@ -365,35 +393,114 @@ ${scriptRegistrations}${templateBody}
 `);
   }
   typeDefinitionToGo(td) {
-    const def = td.definition;
-    if (def.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
+    if (td.definition.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
       return `// ${td.name} is a string type.
 type ${td.name} = string`;
     }
-    const bodyMatch = def.match(/(?:type \w+ = |interface \w+ )\{([\s\S]*)\}/);
-    if (!bodyMatch)
-      return null;
-    const body = bodyMatch[1];
-    const goFields = [];
-    const fieldEntries = body.split(/[;\n]/).map((s) => s.trim()).filter(Boolean);
-    for (const entry of fieldEntries) {
-      const fieldMatch = entry.match(/^(\w+)\??\s*:\s*(.+)$/);
-      if (!fieldMatch)
-        continue;
-      const [, fieldName, tsType] = fieldMatch;
-      const goFieldName = this.capitalizeFieldName(fieldName);
-      const goType = this.tsTypeStringToGo(tsType.trim());
-      const jsonTag = this.toJsonTag(fieldName);
-      goFields.push(`	${goFieldName} ${goType} \`json:"${jsonTag}"\``);
-    }
-    if (goFields.length === 0)
+    const fields = this.structFieldsFor(td);
+    if (fields.length === 0)
       return null;
+    const goFields = fields.map((f) => `	${f.goName} ${f.goType} \`json:"${this.toJsonTag(f.tsName)}"\``);
     return `// ${td.name} represents a ${td.name.toLowerCase()}.
 type ${td.name} struct {
 ${goFields.join(`
 `)}
 }`;
   }
+  structFieldsFor(td) {
+    const fields = [];
+    for (const prop of td.properties ?? []) {
+      if (!GoTemplateAdapter.GO_IDENTIFIER.test(prop.name))
+        continue;
+      fields.push({
+        tsName: prop.name,
+        goName: this.capitalizeFieldName(prop.name),
+        goType: this.typeInfoToGo(prop.type)
+      });
+    }
+    return fields;
+  }
+  synthesizeStructFromSignal(signal, componentName) {
+    if (signal.type.kind !== "array")
+      return null;
+    const elem = signal.type.elementType;
+    if (elem && elem.kind !== "unknown")
+      return null;
+    const node = this.parseLiteralExpression(signal.initialValue);
+    if (!node || !ts.isArrayLiteralExpression(node) || node.elements.length === 0)
+      return null;
+    const order = [];
+    const goTypes = new Map;
+    for (let i = 0;i < node.elements.length; i++) {
+      const el = node.elements[i];
+      if (!ts.isObjectLiteralExpression(el))
+        return null;
+      const seen = new Set;
+      for (const prop of el.properties) {
+        if (!ts.isPropertyAssignment(prop))
+          return null;
+        if (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name) && !ts.isNumericLiteral(prop.name)) {
+          return null;
+        }
+        const key = prop.name.text;
+        if (!GoTemplateAdapter.GO_IDENTIFIER.test(key))
+          return null;
+        const goType = this.scalarLiteralGoType(prop.initializer);
+        if (!goType)
+          return null;
+        seen.add(key);
+        const prev = goTypes.get(key);
+        if (prev === undefined) {
+          if (i !== 0)
+            return null;
+          order.push(key);
+          goTypes.set(key, goType);
+        } else {
+          const merged = this.mergeScalarGoType(prev, goType);
+          if (!merged)
+            return null;
+          goTypes.set(key, merged);
+        }
+      }
+      if (seen.size !== order.length)
+        return null;
+    }
+    const name = `${componentName}${this.capitalizeFieldName(signal.getter)}Item`;
+    if (this.localTypeNames.has(name))
+      return null;
+    return {
+      name,
+      fields: order.map((key) => ({
+        tsName: key,
+        goName: this.capitalizeFieldName(key),
+        goType: goTypes.get(key)
+      }))
+    };
+  }
+  scalarLiteralGoType(node) {
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) {
+      return this.numericLiteralGoType(node.operand.text);
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+      return "string";
+    if (ts.isNumericLiteral(node))
+      return this.numericLiteralGoType(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
+      return "bool";
+    }
+    return null;
+  }
+  numericLiteralGoType(text) {
+    return /[.eE]/.test(text) && !text.startsWith("0x") ? "float64" : "int";
+  }
+  mergeScalarGoType(a, b) {
+    if (a === b)
+      return a;
+    const numeric = new Set(["int", "float64"]);
+    if (numeric.has(a) && numeric.has(b))
+      return "float64";
+    return null;
+  }
   tsTypeStringToGo(tsType) {
     const t = tsType.trim();
     if (t === "number")
@@ -498,6 +605,11 @@ ${goFields.join(`
       if (propFieldNames.has(fieldName))
         continue;
       const jsonTag = this.toJsonTag(signal.getter);
+      const synthType = this.synthStructTypes.get(signal.getter);
+      if (synthType) {
+        lines.push(`	${fieldName} ${this.typeInfoToGo(synthType)} \`json:"${jsonTag}"\``);
+        continue;
+      }
       let goType;
       let referencedProp = propsParamMap.get(signal.initialValue);
       if (!referencedProp) {
@@ -626,7 +738,8 @@ ${goFields.join(`
       if (hoisted) {
         lines.push(`		${fieldName}: ${hoisted.varName},`);
       } else {
-        const initialValue = this.convertInitialValue(signal.initialValue, signal.type, ir.metadata.propsParams);
+        const bakeType = this.synthStructTypes.get(signal.getter) ?? signal.type;
+        const initialValue = this.convertInitialValue(signal.initialValue, bakeType, ir.metadata.propsParams);
         lines.push(`		${fieldName}: ${initialValue},`);
       }
     }
@@ -1007,10 +1120,7 @@ ${goFields.join(`
       }
     }
     if (typeInfo.kind === "array") {
-      if (value === "[]" || value === "null" || value === "undefined") {
-        return "nil";
-      }
-      return "nil";
+      return this.jsLiteralToGo(value, typeInfo) ?? "nil";
     }
     if (typeInfo.kind === "interface" && typeInfo.raw) {
       const aliasBase = this.localTypeAliases.get(typeInfo.raw);
@@ -1023,6 +1133,81 @@ ${goFields.join(`
     }
     return "nil";
   }
+  jsLiteralToGo(value, typeInfo) {
+    const expr = this.parseLiteralExpression(value);
+    if (!expr)
+      return null;
+    return this.tsLiteralToGo(expr, typeInfo);
+  }
+  parseLiteralExpression(value) {
+    const sf = ts.createSourceFile("__lit.ts", `(${value})`, ts.ScriptTarget.Latest, true);
+    if (sf.statements.length !== 1)
+      return null;
+    const stmt = sf.statements[0];
+    if (!ts.isExpressionStatement(stmt))
+      return null;
+    let expr = stmt.expression;
+    while (ts.isParenthesizedExpression(expr))
+      expr = expr.expression;
+    return expr;
+  }
+  tsLiteralToGo(node, typeInfo) {
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) {
+      return `-${node.operand.text}`;
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      return JSON.stringify(node.text);
+    }
+    if (ts.isNumericLiteral(node))
+      return node.text;
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+      return "true";
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+      return "false";
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+      return "nil";
+    if (ts.isArrayLiteralExpression(node)) {
+      if (node.elements.length === 0)
+        return null;
+      const elemType = typeInfo?.kind === "array" ? typeInfo.elementType : undefined;
+      const sliceHeader = typeInfo?.kind === "array" ? this.typeInfoToGo(typeInfo) : "[]interface{}";
+      const elems = [];
+      for (const el of node.elements) {
+        const go = this.tsLiteralToGo(el, elemType);
+        if (go === null)
+          return null;
+        elems.push(go);
+      }
+      return `${sliceHeader}{${elems.join(", ")}}`;
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+      const goType = typeInfo ? this.typeInfoToGo(typeInfo) : "interface{}";
+      const structFields = this.localStructFields.get(goType);
+      if (!structFields)
+        return null;
+      const entries = [];
+      for (const prop of node.properties) {
+        if (!ts.isPropertyAssignment(prop))
+          return null;
+        if (!ts.isIdentifier(prop.name) && !ts.isStringLiteral(prop.name) && !ts.isNumericLiteral(prop.name)) {
+          return null;
+        }
+        const goField = structFields.get(prop.name.text);
+        if (!goField)
+          return null;
+        const init = prop.initializer;
+        if (ts.isObjectLiteralExpression(init) || ts.isArrayLiteralExpression(init)) {
+          return null;
+        }
+        const go = this.tsLiteralToGo(init);
+        if (go === null)
+          return null;
+        entries.push(`${goField}: ${go}`);
+      }
+      return `${goType}{${entries.join(", ")}}`;
+    }
+    return null;
+  }
   typeInfoToGo(typeInfo, defaultValue) {
     switch (typeInfo.kind) {
       case "primitive":
@@ -1335,6 +1520,7 @@ ${goFields.join(`
     }
     return null;
   }
+  static GO_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
   static GO_INITIALISMS = new Set([
     "id",
     "url",
@@ -1541,9 +1727,23 @@ ${goFields.join(`
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
     if (currentLoopParam && name === currentLoopParam)
       return ".";
+    if (this.isOuterLoopParam(name))
+      return `$${name}`;
     if (this.loopVarRefCount.has(name))
       return `$${name}`;
-    return `.${this.capitalizeFieldName(name)}`;
+    return this.rootFieldRef(name);
+  }
+  isOuterLoopParam(name) {
+    const top = this.loopParamStack.length - 1;
+    for (let i = 0;i < top; i++) {
+      if (this.loopParamStack[i] === name)
+        return true;
+    }
+    return false;
+  }
+  rootFieldRef(name) {
+    const prefix = this.loopParamStack.length > 0 ? "$." : ".";
+    return `${prefix}${this.capitalizeFieldName(name)}`;
   }
   literal(value, literalType) {
     if (literalType === "string")
@@ -1554,7 +1754,7 @@ ${goFields.join(`
   }
   call(callee, args, emit) {
     if (callee.kind === "identifier" && args.length === 0) {
-      return `.${this.capitalizeFieldName(callee.name)}`;
+      return this.rootFieldRef(callee.name);
     }
     const path = identifierPath(callee);
     if (path && this.templatePrimitives[path]) {
@@ -1595,7 +1795,7 @@ ${goFields.join(`
         return templateBlock;
     }
     if (object.kind === "identifier" && this.propsObjectName && object.name === this.propsObjectName) {
-      return `.${this.capitalizeFieldName(property)}`;
+      return this.rootFieldRef(property);
     }
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
     if (object.kind === "identifier" && currentLoopParam && object.name === currentLoopParam) {
@@ -2332,11 +2532,14 @@ Options:
           if (currentLoopParam && expr.name === currentLoopParam) {
             return plain(".");
           }
+          if (this.isOuterLoopParam(expr.name)) {
+            return plain(`$${expr.name}`);
+          }
           if (this.loopVarRefCount.has(expr.name)) {
             return plain(`$${expr.name}`);
           }
         }
-        return plain(`.${this.capitalizeFieldName(expr.name)}`);
+        return plain(this.rootFieldRef(expr.name));
       case "literal":
         if (expr.literalType === "string")
           return plain(`"${expr.value}"`);
@@ -2345,7 +2548,7 @@ Options:
         return plain(String(expr.value));
       case "call": {
         if (expr.callee.kind === "identifier" && expr.args.length === 0) {
-          return plain(`.${this.capitalizeFieldName(expr.callee.name)}`);
+          return plain(this.rootFieldRef(expr.callee.name));
         }
         return plain(this.renderParsedExpr(expr));
       }
@@ -2356,7 +2559,7 @@ Options:
             return plain(result);
         }
         if (expr.object.kind === "identifier" && this.propsObjectName && expr.object.name === this.propsObjectName) {
-          return plain(`.${this.capitalizeFieldName(expr.property)}`);
+          return plain(this.rootFieldRef(expr.property));
         }
         {
           const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
@@ -2502,6 +2705,7 @@ Options:
       }
     }
     const children = this.renderChildren(loop.children);
+    const itemMarker = this.loopItemMarker(loop);
     for (const v of addedLoopVars) {
       const rc = (this.loopVarRefCount.get(v) ?? 1) - 1;
       if (rc <= 0)
@@ -2523,12 +2727,18 @@ Options:
       } else {
         filterCond = "true";
       }
-      const itemMarker2 = loop.bodyIsMultiRoot ? `{{bfComment "bf-loop-i"}}` : "";
-      return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}{{if ${filterCond}}}${itemMarker2}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
+      return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}{{if ${filterCond}}}${itemMarker}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
     }
-    const itemMarker = loop.bodyIsMultiRoot ? `{{bfComment "bf-loop-i"}}` : "";
     return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
   }
+  loopItemMarker(loop) {
+    if (loop.bodyIsMultiRoot)
+      return `{{bfComment "bf-loop-i"}}`;
+    if (loop.bodyIsItemConditional && loop.key) {
+      return `{{bfComment (printf "loop-i:%v" ${this.convertExpressionToGo(loop.key)})}}`;
+    }
+    return "";
+  }
   findChildComponent(nodes) {
     for (const node of nodes) {
       if (node.type === "component") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,6 +54,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.5.0"
+    "@barefootjs/jsx": "0.5.2"
   }
 }