@barefootjs/go-template 0.18.3 → 0.18.5

package/dist/index.js

@@ -42,10 +42,11 @@ import {
   collectModuleStringConsts as collectModuleStringConstsShared,
   prepareLoweringMatchers,
   envSignalReaderFor,
-  computeSsrSeedPlan
+  computeSsrSeedPlan,
+  isStringConcatBinary
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
-import { BF_REGION } from "@barefootjs/shared";
+import { BF_REGION, escapeHtml } from "@barefootjs/shared";
 
 // src/adapter/lib/go-naming.ts
 var GO_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -332,6 +333,7 @@ var GO_TEMPLATE_PRIMITIVES = {
   "Math.floor": { arity: 1, emit: (args) => `bf_floor ${wrapGoArg(args[0])}` },
   "Math.ceil": { arity: 1, emit: (args) => `bf_ceil ${wrapGoArg(args[0])}` },
   "Math.round": { arity: 1, emit: (args) => `bf_round ${wrapGoArg(args[0])}` },
+  "Math.abs": { arity: 1, emit: (args) => `bf_abs ${wrapGoArg(args[0])}` },
   "Math.min": { arity: 2, emit: (args) => `bf_min ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` },
   "Math.max": { arity: 2, emit: (args) => `bf_max ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` }
 };
@@ -357,6 +359,7 @@ class CompileState {
   hoistedMemoLocals = new Map;
   loweringMatchers = [];
   nillablePropNames = new Set;
+  stringValueNames = new Set;
   rootScopeNodes = new Set;
   memoBackedLoopSlice = new Map;
   usesHtmlTemplate = false;
@@ -776,7 +779,7 @@ function typeInfoToGo(ctx, typeInfo, defaultValue) {
         case "string":
           return "string";
         case "number":
-          return "int";
+          return defaultValue !== undefined ? numberPrimitiveGoType(defaultValue) : "int";
         case "boolean":
           return "bool";
         default:
@@ -827,6 +830,9 @@ function tsTypeStringToGo(ctx, tsType) {
     return t;
   return "interface{}";
 }
+function numberPrimitiveGoType(value) {
+  return /^-?\d+\.\d+$/.test(value) ? "float64" : "int";
+}
 function inferTypeFromValue(value) {
   if (value === "true" || value === "false")
     return "bool";
@@ -939,9 +945,9 @@ function convertInitialValue(ctx, value, typeInfo, propsParams, preParsed) {
       return value === "true" ? "true" : "false";
     }
     if (typeInfo.primitive === "number") {
-      if (/^\d+$/.test(value))
+      if (/^-?\d+$/.test(value))
         return value;
-      if (/^\d+\.\d+$/.test(value))
+      if (/^-?\d+\.\d+$/.test(value))
         return value;
       return "0";
     }
@@ -966,6 +972,12 @@ function convertInitialValue(ctx, value, typeInfo, propsParams, preParsed) {
       }
       return '""';
     }
+    if (ctx.state.localStructFields.has(typeInfo.raw)) {
+      const baked = jsLiteralToGo(ctx, typeInfo, preParsed);
+      if (baked !== null)
+        return baked;
+      return `${typeInfo.raw}{}`;
+    }
   }
   return "nil";
 }
@@ -1656,10 +1668,11 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
     const operand = String(body.right.value);
     const depName = getterCallName(body.left);
     if (depName) {
-      const signal = signals.find((s) => s.getter === depName);
-      if (signal) {
-        const signalInitial = getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars);
-        return `${signalInitial} ${operator} ${operand}`;
+      const depInitial = resolveGetterValueAsGo(ctx, depName, signals, propsParams, propFallbackVars, resolving);
+      const isArithmeticSafe = depInitial !== null && !depInitial.startsWith("func(");
+      if (isArithmeticSafe) {
+        const wrapped = /\s/.test(depInitial) ? `(${depInitial})` : depInitial;
+        return `${wrapped} ${operator} ${operand}`;
       }
     }
     const propName = propsMemberName(body.left);
@@ -1694,9 +1707,9 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
   }
   const simpleDep = getterCallName(body);
   if (simpleDep) {
-    const signal = signals.find((s) => s.getter === simpleDep);
-    if (signal) {
-      return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars);
+    const depInitial = resolveGetterValueAsGo(ctx, simpleDep, signals, propsParams, propFallbackVars, resolving);
+    if (depInitial !== null) {
+      return depInitial;
     }
   }
   const simpleProp = propsMemberName(body);
@@ -2087,8 +2100,47 @@ function buildPropTypeOverrides(ctx, ir) {
       }
     }
   }
+  for (const propName of collectToFixedPropNames(ir.root)) {
+    const param = ir.metadata.propsParams.find((p) => p.name === propName);
+    if (!param)
+      continue;
+    const resolved = overrides.get(propName) ?? typeInfoToGo(ctx, param.type, param.defaultValue);
+    if (resolved === "int") {
+      overrides.set(propName, "float64");
+    }
+  }
   return overrides;
 }
+function collectToFixedPropNames(root) {
+  const names = new Set;
+  const checkExpr = (expr) => {
+    if (expr?.kind === "array-method" && expr.method === "toFixed" && expr.object.kind === "identifier") {
+      names.add(expr.object.name);
+    }
+  };
+  const walk = (node) => {
+    if (!node)
+      return;
+    if (node.type === "expression")
+      checkExpr(node.parsed);
+    if (node.type === "conditional") {
+      checkExpr(node.parsedCondition);
+      walk(node.whenTrue);
+      walk(node.whenFalse);
+    }
+    if (node.type === "element") {
+      for (const attr of node.attrs) {
+        if (attr.value.kind === "expression")
+          checkExpr(attr.value.parsed);
+      }
+    }
+    if ("children" in node && Array.isArray(node.children)) {
+      node.children.forEach(walk);
+    }
+  };
+  walk(root);
+  return names;
+}
 function resolvePropGoType(ctx, param, propTypeOverrides) {
   const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue);
   if (param.optional && ctx.state.localStructFields.has(base)) {
@@ -2107,6 +2159,30 @@ function collectNillablePropNames(ctx, ir) {
   return nillable;
 }
 
+// src/adapter/props/prop-classes.ts
+function isStringTypeInfo(type) {
+  return type.kind === "primitive" && type.primitive === "string";
+}
+function isBareStringLiteral(initialValue) {
+  if (!initialValue)
+    return false;
+  const v = initialValue.trim();
+  return v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"');
+}
+function collectStringValueNames(ir) {
+  const names = new Set;
+  for (const s of ir.metadata.signals) {
+    if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+      names.add(s.getter);
+    }
+  }
+  for (const p of ir.metadata.propsParams) {
+    if (isStringTypeInfo(p.type))
+      names.add(p.name);
+  }
+  return names;
+}
+
 // src/adapter/go-template-adapter.ts
 var STRING_METHODS = new Set([
   "replace",
@@ -2149,6 +2225,7 @@ class GoTemplateAdapter extends BaseAdapter {
   }
   inLoop = false;
   loopParamStack = [];
+  loopKeyDepthStack = [];
   loopScalarItemStack = [];
   loopWrapperStack = [];
   loopVarRefCount = new Map;
@@ -2196,6 +2273,7 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.pendingChildrenDefines = [];
     this.primeCompileState(ir);
     this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir);
+    this.state.stringValueNames = collectStringValueNames(ir);
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
     }
@@ -2893,6 +2971,13 @@ ${goFields.join(`
                 break;
               }
             }
+            if (parsedValue) {
+              const goVal = parsedLiteralToGo(this.emitCtx, parsedValue);
+              if (goVal !== null) {
+                emitChildField(prop.name, goVal);
+                break;
+              }
+            }
             const resolvedValue = this.resolveDynamicPropValue(exprText, ir.metadata.signals, ir.metadata.memos, ir.metadata.propsParams);
             if (resolvedValue !== null) {
               emitChildField(prop.name, resolvedValue);
@@ -2900,6 +2985,24 @@ ${goFields.join(`
             break;
           }
           case "jsx-children":
+            if (prop.name !== "children") {
+              const text = this.extractTextChildren(prop.value.children);
+              if (text !== null) {
+                emitChildField(prop.name, JSON.stringify(text));
+              } else {
+                const html = this.extractHtmlChildren(prop.value.children);
+                if (html !== null) {
+                  this.state.usesHtmlTemplate = true;
+                  emitChildField(prop.name, `template.HTML(${JSON.stringify(html)})`);
+                } else {
+                  const scopedHtml = this.extractScopedHtmlChildren(prop.value.children);
+                  if (scopedHtml !== null) {
+                    this.state.usesHtmlTemplate = true;
+                    emitChildField(prop.name, `template.HTML(${scopedHtml})`);
+                  }
+                }
+              }
+            }
             break;
         }
       }
@@ -3541,6 +3644,17 @@ ${goFields.join(`
         return computeMemoInitialValueOrNull(this.emitCtx, memo, signals, propsParams, undefined, new Set([memo.name]));
       }
     }
+    const propsObjectName = this.state.propsObjectName;
+    const identifierPattern = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    const bareIdentifier = identifierPattern.test(expr) ? expr : null;
+    const barePropAccess = propsObjectName && expr.startsWith(`${propsObjectName}.`) && identifierPattern.test(expr.slice(propsObjectName.length + 1)) ? expr.slice(propsObjectName.length + 1) : null;
+    const passthroughName = bareIdentifier ?? barePropAccess;
+    const localConst = this.state.localConstants.find((c) => c.name === passthroughName);
+    const isPropsDestructureAlias = localConst !== undefined && propsObjectName !== null && localConst.value === `${propsObjectName}.${passthroughName}`;
+    const shadowedByLocal = passthroughName !== null && (localConst !== undefined && !isPropsDestructureAlias || this.state.localHelperNames.has(passthroughName));
+    if (passthroughName && !shadowedByLocal && propsParams.some((p) => p.name === passthroughName)) {
+      return `in.${capitalizeFieldName(passthroughName)}`;
+    }
     return null;
   }
   inferMemoType(memo, signals, propsParamMap) {
@@ -3665,7 +3779,7 @@ ${goFields.join(`
     return this.renderElement(node);
   }
   emitText(node) {
-    return node.value;
+    return escapeHtml(node.value);
   }
   emitExpression(node) {
     return this.renderExpression(node);
@@ -3925,7 +4039,7 @@ ${goFields.join(`
     const argsStr = args.map(emit).join(" ");
     return `${calleeStr} ${argsStr}`;
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, optional, emit) {
     const objHO = this.higherOrderShapeOf(object);
     if (property === "length" && objHO) {
       const result = this.renderFilterLengthExpr(objHO, emit);
@@ -3967,6 +4081,9 @@ ${goFields.join(`
     const obj = emit(object);
     if (property === "length")
       return `len ${obj}`;
+    if (optional) {
+      return `bf_get ${wrapIfMultiToken(obj)} ${JSON.stringify(goFieldNameForKey(property))}`;
+    }
     return `${obj}.${goFieldNameForKey(property)}`;
   }
   indexAccess(object, index, emit) {
@@ -3997,7 +4114,7 @@ ${goFields.join(`
       case "<=":
         return `le ${wl} ${wr}`;
       case "+":
-        return `bf_add ${wl} ${wr}`;
+        return this._emitPlus(left, right, wl, wr);
       case "-":
         return `bf_sub ${wl} ${wr}`;
       case "*":
@@ -4010,6 +4127,15 @@ ${goFields.join(`
         return `${l} ${op} ${r}`;
     }
   }
+  _emitPlus(leftExpr, rightExpr, leftRendered, rightRendered) {
+    if (isStringConcatBinary("+", leftExpr, rightExpr, (n) => this._isStringValueName(n))) {
+      return `bf_concat_str ${leftRendered} ${rightRendered}`;
+    }
+    return `bf_add ${leftRendered} ${rightRendered}`;
+  }
+  _isStringValueName(name) {
+    return this.state.stringValueNames.has(name);
+  }
   unary(op, argument, emit) {
     const arg = emit(argument);
     if (op === "!")
@@ -4221,6 +4347,12 @@ ${goFields.join(`
         const recv = emit(object);
         return `bf_trim ${wrapIfMultiToken(recv)}`;
       }
+      case "trimStart":
+      case "trimEnd": {
+        const fn = method === "trimStart" ? "bf_trim_start" : "bf_trim_end";
+        const recv = emit(object);
+        return `${fn} ${wrapIfMultiToken(recv)}`;
+      }
       case "toFixed": {
         const recv = emit(object);
         const digits = args.length >= 1 ? emit(args[0]) : "0";
@@ -4255,6 +4387,12 @@ ${goFields.join(`
         const newS = emit(args[1]);
         return `bf_replace ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(oldS)} ${wrapIfMultiToken(newS)}`;
       }
+      case "replaceAll": {
+        const recv = emit(object);
+        const oldS = emit(args[0]);
+        const newS = emit(args[1]);
+        return `bf_replace_all ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(oldS)} ${wrapIfMultiToken(newS)}`;
+      }
       case "repeat": {
         const recv = emit(object);
         const count = args.length === 0 ? "0" : emit(args[0]);
@@ -4561,7 +4699,7 @@ ${goFields.join(`
           case "<=":
             return `le ${left} ${right}`;
           case "+":
-            return `bf_add ${left} ${right}`;
+            return this._emitPlus(expr.left, expr.right, left, right);
           case "-":
             return `bf_sub ${left} ${right}`;
           case "*":
@@ -4930,7 +5068,7 @@ ${goFields.join(`
             result = `le ${left} ${right}`;
             break;
           case "+":
-            result = `bf_add ${left} ${right}`;
+            result = this._emitPlus(expr.left, expr.right, left, right);
             break;
           case "-":
             result = `bf_sub ${left} ${right}`;
@@ -5087,7 +5225,9 @@ ${goFields.join(`
     }
     this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null);
     this.loopWrapperStack.push(!!loop.childComponent);
+    this.loopKeyDepthStack.push(loop.depth);
     const children = this.renderChildren(loop.children);
+    this.loopKeyDepthStack.pop();
     this.loopWrapperStack.pop();
     this.loopScalarItemStack.pop();
     const itemMarker = this.loopItemMarker(loop);
@@ -5230,7 +5370,7 @@ ${goFields.join(`
 ${children}`;
   }
   elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       if (name === "style") {
         const css = this.tryLowerStyleObject(value.expr);
@@ -5320,9 +5460,10 @@ ${children}`;
       let attrName;
       if (attr.name === "className")
         attrName = "class";
-      else if (attr.name === "key")
-        attrName = "data-key";
-      else
+      else if (attr.name === "key") {
+        const depth = this.loopKeyDepthStack.at(-1) ?? 0;
+        attrName = depth > 0 ? `data-key-${depth}` : "data-key";
+      } else
         attrName = attr.name;
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
       if (lowered)
@@ -5437,30 +5578,10 @@ var conformancePins = {
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
   "array-map-function-reference": [{ code: "BF101", severity: "error" }],
-  "dangerous-inner-html": [{ code: "BF101", severity: "error" }],
-  "string-replaceall": [{ code: "BF101", severity: "error" }]
+  "dangerous-inner-html": [{ code: "BF101", severity: "error" }]
 };
 // src/render-divergences.ts
-var renderDivergences = {
-  "html-entity-text": "`&copy;` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes",
-  "string-concat-plus": "`'Hello, ' + name` renders \"0\" — JS string-concat `+` lowered through numeric addition",
-  "optional-chaining-prop": "`user?.name ?? …` on an object prop: generated Go fails to run (exit 1) — optional chaining into a struct/map prop has no lowering",
-  "number-tofixed": "`.toFixed(2)` on a number PROP: generated Go fails to run (exit 1)",
-  "math-methods": "Math.min/max/abs over a signal: generated Go fails to run (exit 1) — only Math.floor is registered",
-  "boolean-attr-literals": 'camelCase boolean alias `readOnly`: Hono SSRs `readOnly="true"`, this adapter emits bare presence',
-  "camelcase-attributes": "`htmlFor` is not lowered to `for` (Hono maps it)",
-  "static-attr-escape": 'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  "svg-icon": "SVG camelCase presentation attrs (`strokeWidth`, `strokeLinecap`) pass through unmapped; Hono lowers to kebab-case",
-  "object-entries-map": "`Object.entries(prop).map(([k, v]) => …)`: generated Go fails to run (exit 1) — no object-iteration loop lowering",
-  "nested-loop-outer-binding": "nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`",
-  "jsx-element-prop": "a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped",
-  "grandchild-composition": "three-level composition: the grandchild's threaded prop renders EMPTY — prop forwarding through two template-render layers loses the value",
-  "child-primitive-props": "numeric/boolean LITERAL props on a child (`count={5}` `active={true}`) render as Go zero values (0 / false)",
-  "memo-chain": "a memo derived from another memo renders EMPTY for the second layer — the constructor folds only one derivation level",
-  "signal-object-field": "object-valued signal (`user().name`): generated Go fails to run (exit 1) — no struct synthesis outside loops",
-  "string-slice": '`.slice()` on a STRING routes through the array `bf_slice` helper and renders "[]" instead of the substring',
-  "string-trim-sided": "`.trimStart()` / `.trimEnd()`: generated Go fails to run (exit 1) — only both-sides `bf_trim` exists"
-};
+var renderDivergences = {};
 export {
   renderDivergences,
   goTemplateAdapter,

package/dist/render-divergences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAqC/B,CAAA"}
+{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAC/B,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.18.3",
+  "version": "0.18.5",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/adapter-go-template"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.18.3"
+    "@barefootjs/shared": "0.18.5"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -57,6 +57,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.18.3"
+    "@barefootjs/jsx": "0.18.5"
   }
 }

package/src/__tests__/go-template-adapter.test.ts

@@ -2286,7 +2286,7 @@ export function Tagged(props: { className?: string }) {
       // list rather than replace.
       const a = new GoTemplateAdapter()
       const keys = Object.keys(a.templatePrimitives ?? {}).sort()
-      expect(keys).toEqual(['JSON.stringify', 'Math.ceil', 'Math.floor', 'Math.max', 'Math.min', 'Math.round', 'Number', 'String'])
+      expect(keys).toEqual(['JSON.stringify', 'Math.abs', 'Math.ceil', 'Math.floor', 'Math.max', 'Math.min', 'Math.round', 'Number', 'String'])
     })
 
     test('unregistered identifier-path callee is NOT accepted by the registry', () => {