@barefootjs/go-template 0.5.1 → 0.5.3

package/dist/build.js

@@ -430,6 +430,8 @@ class GoTemplateAdapter extends BaseAdapter {
   templateVarCounter = 0;
   localTypeNames = new Set;
   localTypeAliases = new Map;
+  localStructFields = new Map;
+  synthStructTypes = new Map;
   usesHtmlTemplate = false;
   constructor(options = {}) {
     super();
@@ -663,6 +665,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;
@@ -671,6 +674,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) {
@@ -684,6 +692,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);
@@ -705,35 +733,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")
@@ -838,6 +945,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) {
@@ -966,7 +1078,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},`);
       }
     }
@@ -1347,10 +1460,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);
@@ -1363,6 +1473,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":
@@ -1675,6 +1860,7 @@ ${goFields.join(`
     }
     return null;
   }
+  static GO_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
   static GO_INITIALISMS = new Set([
     "id",
     "url",
@@ -1881,9 +2067,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")
@@ -1894,7 +2094,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]) {
@@ -1935,7 +2135,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) {
@@ -2672,11 +2872,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}"`);
@@ -2685,7 +2888,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));
       }
@@ -2696,7 +2899,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];