@barefootjs/go-template 0.35.0 → 0.35.2

package/dist/vite.js

@@ -8,7 +8,7 @@ import { devModuleUrl, loadManifest, resolveDevOrigin, resolveScriptAssets, toPo
 import ts25 from "typescript";
 
 // ../jsx/src/analyzer.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 
 // ../jsx/src/expression-parser.ts
 import ts from "typescript";
@@ -2462,14 +2462,17 @@ function freshCounters() {
 }
 
 // ../jsx/src/analyzer-context.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // ../jsx/src/strip-types.ts
 import ts8 from "typescript";
 
+// ../jsx/src/reactivity-checker.ts
+import ts9 from "typescript";
+
 // ../jsx/src/analyzer-context.ts
-var _typePrinter = ts9.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-var _blankTypeSourceFile = ts9.createSourceFile("__bf_types__.ts", "", ts9.ScriptTarget.Latest);
+var _typePrinter = ts10.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+var _blankTypeSourceFile = ts10.createSourceFile("__bf_types__.ts", "", ts10.ScriptTarget.Latest);
 
 // ../jsx/src/errors.ts
 var ErrorCodes = {
@@ -2702,46 +2705,46 @@ function extractFreeIdentifiersFromNode(node) {
   const ids = new Set;
   const boundNames = new Set;
   function addBindingNames(name, out) {
-    if (ts10.isIdentifier(name))
+    if (ts11.isIdentifier(name))
       out.push(name.text);
-    else if (ts10.isObjectBindingPattern(name))
+    else if (ts11.isObjectBindingPattern(name))
       name.elements.forEach((e) => addBindingNames(e.name, out));
-    else if (ts10.isArrayBindingPattern(name))
+    else if (ts11.isArrayBindingPattern(name))
       name.elements.forEach((e) => {
-        if (!ts10.isOmittedExpression(e))
+        if (!ts11.isOmittedExpression(e))
           addBindingNames(e.name, out);
       });
   }
   function visit(n) {
-    if (ts10.isTypeNode(n))
+    if (ts11.isTypeNode(n))
       return;
-    if (ts10.isIdentifier(n)) {
+    if (ts11.isIdentifier(n)) {
       const parent = n.parent;
-      if (parent && ts10.isPropertyAccessExpression(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAccessExpression(parent) && parent.name === n)
         return;
-      if (parent && ts10.isPropertyAssignment(parent) && parent.name === n)
+      if (parent && ts11.isPropertyAssignment(parent) && parent.name === n)
         return;
-      if (parent && ts10.isParameter(parent) && parent.name === n)
+      if (parent && ts11.isParameter(parent) && parent.name === n)
         return;
-      if (parent && ts10.isVariableDeclaration(parent) && parent.name === n)
+      if (parent && ts11.isVariableDeclaration(parent) && parent.name === n)
         return;
       if (boundNames.has(n.text))
         return;
       ids.add(n.text);
       return;
     }
-    if (ts10.isArrowFunction(n)) {
+    if (ts11.isArrowFunction(n)) {
       const params = [];
       for (const p of n.parameters)
         addBindingNames(p.name, params);
       for (const name of params)
         boundNames.add(name);
-      ts10.forEachChild(n, visit);
+      ts11.forEachChild(n, visit);
       for (const name of params)
         boundNames.delete(name);
       return;
     }
-    ts10.forEachChild(n, visit);
+    ts11.forEachChild(n, visit);
   }
   visit(node);
   return ids;
@@ -2815,7 +2818,7 @@ function preambleAnalysisTemplateText(p) {
 }
 
 // ../jsx/src/module-exports.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function formatParamWithType(p) {
   const rest = p.isRest ? "..." : "";
   const optional = p.optional ? "?" : "";
@@ -2850,21 +2853,21 @@ function findAssignedNames(bodyText, candidates) {
   const assigned = new Set;
   if (candidates.size === 0)
     return assigned;
-  const sf = ts11.createSourceFile("bf-assignment-scan.tsx", bodyText, ts11.ScriptTarget.Latest, false, ts11.ScriptKind.TSX);
+  const sf = ts12.createSourceFile("bf-assignment-scan.tsx", bodyText, ts12.ScriptTarget.Latest, false, ts12.ScriptKind.TSX);
   const record = (target) => {
-    if (ts11.isIdentifier(target) && candidates.has(target.text)) {
+    if (ts12.isIdentifier(target) && candidates.has(target.text)) {
       assigned.add(target.text);
     }
   };
   const visit = (node) => {
-    if (ts11.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
+    if (ts12.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
       record(node.left);
-    } else if ((ts11.isPrefixUnaryExpression(node) || ts11.isPostfixUnaryExpression(node)) && (node.operator === ts11.SyntaxKind.PlusPlusToken || node.operator === ts11.SyntaxKind.MinusMinusToken)) {
+    } else if ((ts12.isPrefixUnaryExpression(node) || ts12.isPostfixUnaryExpression(node)) && (node.operator === ts12.SyntaxKind.PlusPlusToken || node.operator === ts12.SyntaxKind.MinusMinusToken)) {
       record(node.operand);
     }
-    ts11.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   };
-  ts11.forEachChild(sf, visit);
+  ts12.forEachChild(sf, visit);
   return assigned;
 }
 function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNames) {
@@ -2887,12 +2890,9 @@ function closeOverWritersOfMutableBindings(primaryRefs, declarations, mutableNam
   return reachable;
 }
 function isAssignmentOperator(kind) {
-  return kind >= ts11.SyntaxKind.FirstAssignment && kind <= ts11.SyntaxKind.LastAssignment;
+  return kind >= ts12.SyntaxKind.FirstAssignment && kind <= ts12.SyntaxKind.LastAssignment;
 }
 
-// ../jsx/src/reactivity-checker.ts
-import ts12 from "typescript";
-
 // ../jsx/src/free-refs.ts
 import ts13 from "typescript";
 var _bindingMapCache = new WeakMap;
@@ -6183,21 +6183,38 @@ function lowerUrlGuard(ctx, g) {
   if (isBoolShape) {
     return ctx.convertConditionToGo(stringifyParsedExpr(g), g).condition;
   }
-  const valueGo = wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(g), undefined, g));
+  const valueGo = lowerValueOperand(ctx, g);
   return `ne ${valueGo} ""`;
 }
 function lowerTernary(ctx, test, consequent, alternate) {
   const t = lowerTernaryTest(ctx, test);
-  return `(bf_ternary ${t} ${lowerTernaryOperand(ctx, consequent)} ${lowerTernaryOperand(ctx, alternate)})`;
+  return `(bf_ternary ${t} ${lowerValueOperand(ctx, consequent)} ${lowerValueOperand(ctx, alternate)})`;
+}
+function lowerTemplateLiteralValue(ctx, parts) {
+  const terms = [];
+  for (const part of parts) {
+    if (part.type === "string") {
+      if (part.value !== "")
+        terms.push(`"${escapeGoString(part.value)}"`);
+    } else {
+      terms.push(lowerValueOperand(ctx, part.expr));
+    }
+  }
+  if (terms.length === 0)
+    return '""';
+  return terms.slice(1).reduce((acc, t) => `(bf_concat_str ${acc} ${t})`, terms[0]);
 }
-function lowerTernaryOperand(ctx, n) {
+function lowerValueOperand(ctx, n) {
   if (n.kind === "conditional") {
     return lowerTernary(ctx, n.test, n.consequent, n.alternate);
   }
+  if (n.kind === "template-literal") {
+    return wrapIfMultiToken(lowerTemplateLiteralValue(ctx, n.parts));
+  }
   return wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n));
 }
 function lowerTernaryTest(ctx, test) {
-  const go = wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(test), undefined, test));
+  const go = lowerValueOperand(ctx, test);
   const isBoolShape = test.kind === "binary" && BOOL_COMPARISON_OPS.has(test.op) || test.kind === "unary" && test.op === "!" || test.kind === "literal" && test.literalType === "boolean";
   return isBoolShape ? go : `(bf_truthy ${go})`;
 }
@@ -6258,18 +6275,16 @@ function renderLoweringNode(ctx, node) {
   const helper = goHelperName(node.helper);
   if (!helper)
     return null;
-  const lowerExpr = (n) => ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n);
-  const lowerArg = (n) => n.kind === "conditional" ? lowerTernary(ctx, n.test, n.consequent, n.alternate) : wrapIfMultiToken(lowerExpr(n));
   if (node.kind === "helper-call") {
-    const args = node.args.map((a) => lowerArg(a));
+    const args = node.args.map((a) => lowerValueOperand(ctx, a));
     return [helper, ...args].join(" ");
   }
-  const parts = [wrapIfMultiToken(lowerExpr(node.base))];
+  const parts = [lowerValueOperand(ctx, node.base)];
   for (const t of node.triples) {
     const includeGo = t.guard === null ? "true" : lowerUrlGuard(ctx, t.guard);
     parts.push(`(${includeGo})`);
     parts.push(JSON.stringify(t.key));
-    parts.push(wrapIfMultiToken(lowerExpr(t.value)));
+    parts.push(lowerValueOperand(ctx, t.value));
   }
   return `${helper} ${parts.join(" ")}`;
 }
@@ -6509,12 +6524,9 @@ function convertInitialValue(ctx, value, _typeInfo, propsParams, preParsed) {
     const inlinedStr = ctx.resolveModuleStringConst(value);
     if (inlinedStr !== null)
       return inlinedStr;
-    const inlinedNum = ctx.resolveModuleNumericConst(value);
-    if (inlinedNum !== null)
-      return inlinedNum;
-    const inlinedBool = ctx.resolveModuleBooleanConst(value);
-    if (inlinedBool !== null)
-      return inlinedBool;
+    const inlinedConst = ctx.resolveModuleConstAsGo(value, { kind: "go-source", bakeType: typeInfo });
+    if (inlinedConst !== null)
+      return inlinedConst;
   }
   const propName = ctx.extractPropNameFromInitialValue(value, preParsed);
   const param = propName ? propsParams?.find((p) => p.name === propName) : undefined;
@@ -8223,8 +8235,7 @@ class GoTemplateAdapter extends BaseAdapter {
     extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     extractCollisionDerivation: (parsed) => this.extractCollisionDerivation(parsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
-    resolveModuleNumericConst: (name) => this.resolveModuleNumericConst(name),
-    resolveModuleBooleanConst: (name) => this.resolveModuleBooleanConst(name)
+    resolveModuleConstAsGo: (name, target) => this.resolveModuleConstAsGo(name, target)
   };
   get errors() {
     return this.state.errors;
@@ -10422,9 +10433,9 @@ ${goFields.join(`
     const inlined = this.resolveModuleStringConst(name);
     if (inlined !== null)
       return inlined;
-    const inlinedNum = this.resolveModuleNumericConst(name);
-    if (inlinedNum !== null)
-      return inlinedNum;
+    const inlinedScalar = this.resolveModuleConstAsGo(name, { kind: "template-action" });
+    if (inlinedScalar !== null)
+      return inlinedScalar;
     if (this.isCurrentLoopItem(name))
       return ".";
     if (this.isOuterLoopParam(name))
@@ -10501,11 +10512,18 @@ ${goFields.join(`
     return hit !== null && hit.depth > 0 && hit.binding.source === "item";
   }
   rootFieldRef(name) {
-    const resolved = this.state.getterAliases.get(name) ?? this.state.propDestructureAliases.get(name) ?? name;
+    const resolved = this.resolveRootFieldAlias(name);
     this.state.templateReadRootFields.add(resolved);
     const prefix = this.inLoop ? "$." : ".";
     return `${prefix}${capitalizeFieldName(resolved)}`;
   }
+  resolveRootFieldAlias(name) {
+    return this.state.getterAliases.get(name) ?? this.state.propDestructureAliases.get(name) ?? name;
+  }
+  filterRootFieldRef(name) {
+    this.rootFieldRef(name);
+    return `$.${capitalizeFieldName(this.resolveRootFieldAlias(name))}`;
+  }
   searchParamsFieldRef(name) {
     return this.state.searchParamsLocals.has(name) ? this.rootFieldRef("searchParams") : null;
   }
@@ -10527,7 +10545,7 @@ ${goFields.join(`
   findModuleConst(name) {
     return this.state.localConstants.find((k) => k.name === name && k.isModule && !k.containsArrow);
   }
-  resolveModuleNumericConst(name) {
+  resolveModuleConstAsGo(name, target) {
     if (this.isCurrentLoopItem(name))
       return null;
     if (this.loopVarRefCount.has(name))
@@ -10535,23 +10553,13 @@ ${goFields.join(`
     if (this.isOuterLoopParam(name))
       return null;
     const c = this.findModuleConst(name);
-    if (!c || c.value === undefined)
-      return null;
-    const v = c.value.trim().replace(/(?<=\d)_(?=\d)/g, "");
-    return /^-?\d+(\.\d+)?$/.test(v) ? v : null;
-  }
-  resolveModuleBooleanConst(name) {
-    if (this.isCurrentLoopItem(name))
+    if (!c?.parsed)
       return null;
-    if (this.loopVarRefCount.has(name))
-      return null;
-    if (this.isOuterLoopParam(name))
-      return null;
-    const c = this.findModuleConst(name);
-    if (!c || c.value === undefined)
-      return null;
-    const v = c.value.trim();
-    return v === "true" || v === "false" ? v : null;
+    if (target.kind === "template-action") {
+      return c.parsed.kind === "literal" || c.parsed.kind === "unary" ? parsedLiteralToGo(this.emitCtx, c.parsed) : null;
+    }
+    const bakeType = target.bakeType.kind !== "unknown" ? target.bakeType : c.type ?? undefined;
+    return parsedLiteralToGo(this.emitCtx, c.parsed, bakeType);
   }
   literal(value, literalType) {
     if (literalType === "string")
@@ -10640,11 +10648,17 @@ ${goFields.join(`
     return `${obj}.${goFieldNameForKey(property)}`;
   }
   indexAccess(object, index, emit) {
-    return `bf_get ${wrapIfMultiToken(emit(object))} ${wrapIfMultiToken(emit(index))}`;
+    return `bf_get ${wrapIfMultiToken(this.emitOperand(object, emit))} ${wrapIfMultiToken(this.emitOperand(index, emit))}`;
+  }
+  emitOperand(n, emit) {
+    if (n.kind === "template-literal") {
+      return wrapIfMultiToken(lowerTemplateLiteralValue(this.emitCtx, n.parts));
+    }
+    return emit(n);
   }
   binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
+    const l = this.emitOperand(left, emit);
+    const r = this.emitOperand(right, emit);
     const wl = wrapIfMultiToken(l);
     const wr = wrapIfMultiToken(r);
     switch (op) {
@@ -10690,7 +10704,7 @@ ${goFields.join(`
     return this.state.stringValueNames.has(name);
   }
   unary(op, argument, emit) {
-    const arg = emit(argument);
+    const arg = this.emitOperand(argument, emit);
     if (op === "!")
       return `not ${wrapIfMultiToken(arg)}`;
     if (op === "-")
@@ -10698,8 +10712,8 @@ ${goFields.join(`
     return arg;
   }
   logical(op, left, right, emit) {
-    const wrapLeft = wrapIfMultiToken(emit(left));
-    const wrapRight = wrapIfMultiToken(emit(right));
+    const wrapLeft = wrapIfMultiToken(this.emitOperand(left, emit));
+    const wrapRight = wrapIfMultiToken(this.emitOperand(right, emit));
     if (op === "&&")
       return `and ${wrapLeft} ${wrapRight}`;
     if (op === "??" && this.nillablePropNameOf(left) !== null) {
@@ -10864,7 +10878,8 @@ ${goFields.join(`
     }
     return this.pushCallbackBF101(method, true);
   }
-  arrayMethod(method, object, args, emit) {
+  arrayMethod(method, object, args, rawEmit) {
+    const emit = (e) => this.emitOperand(e, rawEmit);
     switch (method) {
       case "join": {
         const obj = emit(object);
@@ -11193,11 +11208,9 @@ ${goFields.join(`
         }
         const signal = localVarMap.get(expr.name);
         if (signal) {
-          this.rootFieldRef(signal);
-          return `$.${capitalizeFieldName(signal)}`;
+          return this.filterRootFieldRef(signal);
         }
-        this.rootFieldRef(expr.name);
-        return `.${capitalizeFieldName(expr.name)}`;
+        return this.filterRootFieldRef(expr.name);
       }
       case "literal":
         if (expr.literalType === "string") {
@@ -11211,6 +11224,9 @@ ${goFields.join(`
         if (expr.object.kind === "identifier" && expr.object.name === param) {
           return `${paramPrefix}.${capitalizeFieldName(expr.property)}`;
         }
+        if (expr.object.kind === "identifier" && this.state.propsObjectName && expr.object.name === this.state.propsObjectName) {
+          return this.filterRootFieldRef(expr.property);
+        }
         if (expr.property === "length") {
           const innerHO = this.higherOrderShapeOf(expr.object);
           if (innerHO && innerHO.method === "filter") {
@@ -11229,8 +11245,7 @@ ${goFields.join(`
           return `${paramPrefix}.${capitalizeFieldName(expr.callee.property)}`;
         }
         if (expr.callee.kind === "identifier" && expr.args.length === 0) {
-          this.rootFieldRef(expr.callee.name);
-          return `$.${capitalizeFieldName(expr.callee.name)}`;
+          return this.filterRootFieldRef(expr.callee.name);
         }
         if (asCallbackMethodCall(expr) !== null) {
           return this.refuseFilterExprNode(expr);
@@ -11260,29 +11275,33 @@ ${goFields.join(`
         const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
+        const wl = wrapIfMultiToken(left);
+        const wr = wrapIfMultiToken(right);
         switch (expr.op) {
           case "===":
           case "==":
-            return `eq ${left} ${right}`;
+            return `eq ${wl} ${wr}`;
           case "!==":
           case "!=":
-            return `ne ${left} ${right}`;
+            return `ne ${wl} ${wr}`;
           case ">":
-            return `gt ${left} ${right}`;
+            return `gt ${wl} ${wr}`;
           case "<":
-            return `lt ${left} ${right}`;
+            return `lt ${wl} ${wr}`;
           case ">=":
-            return `ge ${left} ${right}`;
+            return `ge ${wl} ${wr}`;
           case "<=":
-            return `le ${left} ${right}`;
+            return `le ${wl} ${wr}`;
           case "+":
-            return this._emitPlus(expr.left, expr.right, left, right);
+            return this._emitPlus(expr.left, expr.right, wl, wr);
           case "-":
-            return `bf_sub ${left} ${right}`;
+            return `bf_sub ${wl} ${wr}`;
           case "*":
-            return `bf_mul ${left} ${right}`;
+            return `bf_mul ${wl} ${wr}`;
           case "/":
-            return `bf_div ${left} ${right}`;
+            return `bf_div ${wl} ${wr}`;
+          case "%":
+            return `bf_mod ${wl} ${wr}`;
           default:
             return `${left} ${expr.op} ${right}`;
         }
@@ -11454,11 +11473,9 @@ ${goFields.join(`
         }
         continue;
       }
-      const singlePartTemplateLiteral = exprOut.parsed?.kind === "template-literal" && exprOut.parsed.parts.length === 1 && exprOut.parsed.parts[0].type !== "string" && go.startsWith("{{") && go.endsWith("}}");
-      if (singlePartTemplateLiteral) {
-        go = go.slice(2, -2);
-      }
-      if (!singlePartTemplateLiteral && this.isTemplateFragment(go, exprOut.parsed?.kind)) {
+      if (exprOut.parsed?.kind === "template-literal" || exprOut.parsed?.kind === "conditional") {
+        go = lowerValueOperand(this.emitCtx, exprOut.parsed);
+      } else if (this.isTemplateFragment(go, exprOut.parsed?.kind)) {
         this.state.errors.push({
           code: "BF101",
           severity: "error",
@@ -11735,6 +11752,9 @@ ${goFields.join(`
           case "/":
             result = `bf_div ${left} ${right}`;
             break;
+          case "%":
+            result = `bf_mod ${left} ${right}`;
+            break;
           default:
             result = `${left} ${expr.op} ${right}`;
         }
@@ -11761,7 +11781,7 @@ ${goFields.join(`
         return plain(lowerTernary(this.emitCtx, expr.test, expr.consequent, expr.alternate));
       }
       case "template-literal":
-        return plain(this.renderParsedExpr(expr));
+        return plain(lowerTemplateLiteralValue(this.emitCtx, expr.parts));
       case "arrow":
         return plain("[ARROW-FN]");
       case "regex":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.35.0",
+  "version": "0.35.2",
   "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.35.0"
+    "@barefootjs/shared": "0.35.2"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -67,9 +67,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/client": "0.35.0",
-    "@barefootjs/jsx": "0.35.0",
-    "@barefootjs/vite": "0.35.0",
+    "@barefootjs/client": "0.35.2",
+    "@barefootjs/jsx": "0.35.2",
+    "@barefootjs/vite": "0.35.2",
     "vite": "^6.0.0"
   }
 }