@barefootjs/go-template 0.18.4 → 0.18.5

package/dist/build.js

@@ -382,10 +382,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_]*$/;
@@ -672,6 +673,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])}` }
 };
@@ -697,6 +699,7 @@ class CompileState {
   hoistedMemoLocals = new Map;
   loweringMatchers = [];
   nillablePropNames = new Set;
+  stringValueNames = new Set;
   rootScopeNodes = new Set;
   memoBackedLoopSlice = new Map;
   usesHtmlTemplate = false;
@@ -1116,7 +1119,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:
@@ -1167,6 +1170,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";
@@ -1279,9 +1285,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";
     }
@@ -1306,6 +1312,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";
 }
@@ -1996,10 +2008,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);
@@ -2034,9 +2047,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);
@@ -2427,8 +2440,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)) {
@@ -2447,6 +2499,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",
@@ -2489,6 +2565,7 @@ class GoTemplateAdapter extends BaseAdapter {
   }
   inLoop = false;
   loopParamStack = [];
+  loopKeyDepthStack = [];
   loopScalarItemStack = [];
   loopWrapperStack = [];
   loopVarRefCount = new Map;
@@ -2536,6 +2613,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);
     }
@@ -3233,6 +3311,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);
@@ -3240,6 +3325,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;
         }
       }
@@ -3881,6 +3984,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) {
@@ -4005,7 +4119,7 @@ ${goFields.join(`
     return this.renderElement(node);
   }
   emitText(node) {
-    return node.value;
+    return escapeHtml(node.value);
   }
   emitExpression(node) {
     return this.renderExpression(node);
@@ -4265,7 +4379,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);
@@ -4307,6 +4421,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) {
@@ -4337,7 +4454,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 "*":
@@ -4350,6 +4467,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 === "!")
@@ -4561,6 +4687,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";
@@ -4595,6 +4727,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]);
@@ -4901,7 +5039,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 "*":
@@ -5270,7 +5408,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}`;
@@ -5427,7 +5565,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);
@@ -5570,7 +5710,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);
@@ -5660,9 +5800,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)

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,eAqI7B,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,eAgI7B,CAAA"}