@barefootjs/go-template 0.17.0 → 0.17.1

package/dist/index.js

@@ -31,7 +31,7 @@ import {
   isSupported,
   exprToString,
   identifierPath,
-  asCallbackMethodCall,
+  asCallbackMethodCall as asCallbackMethodCall3,
   sortComparatorFromArrow,
   emitParsedExpr,
   emitIRNode,
@@ -40,8 +40,9 @@ import {
   collectContextConsumers,
   isLowerableObjectRestDestructure,
   collectModuleStringConsts as collectModuleStringConstsShared,
-  searchParamsLocalNames,
-  prepareLoweringMatchers
+  prepareLoweringMatchers,
+  envSignalReaderFor,
+  computeSsrSeedPlan
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
 import { BF_REGION } from "@barefootjs/shared";
@@ -224,6 +225,13 @@ function emitFlatMapEval(recv, body, param, emit) {
   const env = emitEvalEnvArg(body, [param], emit);
   return `bf_flat_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`;
 }
+function emitMapEval(recv, body, param, emit) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  const env = emitEvalEnvArg(body, [param], emit);
+  return `bf_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`;
+}
 function stringTolerantEqOperands(l, r) {
   const isStrLit = (x) => /^"(?:[^"\\]|\\.)*"$/.test(x);
   if (isStrLit(l) === isStrLit(r))
@@ -337,6 +345,9 @@ class CompileState {
   currentTypeDefinitions = [];
   contextConsumers = [];
   searchParamsLocals = new Set;
+  envSignalReadersByLocal = new Map;
+  ssrSeedPlan = { baseScope: [], steps: [] };
+  hoistedMemoLocals = new Map;
   loweringMatchers = [];
   nillablePropNames = new Set;
   rootScopeNodes = new Set;
@@ -977,8 +988,17 @@ function getSignalInitialValueAsGo(ctx, initialValue, propsParams, propFallbackV
 }
 
 // src/adapter/memo/memo-type.ts
+import { asCallbackMethodCall } from "@barefootjs/jsx";
+function isListFilterMemo(memo) {
+  if (!memo.parsed)
+    return false;
+  const cb = asCallbackMethodCall(memo.parsed);
+  return cb !== null && cb.method === "filter";
+}
 function isBooleanMemo(ctx, memo, signals, propsParamMap) {
   const c = memo.computation;
+  if (isListFilterMemo(memo))
+    return false;
   if (isStringTernaryMemo(ctx, memo.parsed))
     return false;
   if (/(!==|===|!=(?!=)|==(?!=))/.test(c))
@@ -1269,6 +1289,14 @@ function computeObjectMemoInitialValue(ctx, memo) {
 	}`;
 }
 
+// src/adapter/memo/memo-compute.ts
+import {
+  asCallbackMethodCall as asCallbackMethodCall2,
+  freeVarsInBody as freeVarsInBody2,
+  materializeGetterCalls,
+  serializeParsedExpr as serializeParsedExpr2
+} from "@barefootjs/jsx";
+
 // src/adapter/memo/template-interp.ts
 import ts from "typescript";
 function computeTemplateLiteralMemoInitialValue(ctx, memo, propsParams) {
@@ -1409,8 +1437,49 @@ function propsAccessNameFromParsed(ctx, node) {
 
 // src/adapter/memo/memo-compute.ts
 var EMPTY_PROP_FALLBACK_VARS2 = new Map;
+function getterCallName(e) {
+  return e.kind === "call" && e.callee.kind === "identifier" && e.args.length === 0 ? e.callee.name : null;
+}
+function propsMemberName(e) {
+  return e.kind === "member" && !e.computed && e.object.kind === "identifier" && e.object.name === "props" ? e.property : null;
+}
+function matchFilterArmMemo(ctx, body, signals, propsParams) {
+  const cb = asCallbackMethodCall2(body);
+  if (!cb || cb.method !== "filter")
+    return null;
+  const propName = propsMemberName(cb.object);
+  const param = propName ? propsParams.find((p) => p.name === propName) : undefined;
+  if (!propName || !param)
+    return null;
+  const knownGetterNames = new Set(ctx.state.ssrSeedPlan.steps.filter((s) => s.kind !== "env-reader").map((s) => s.name));
+  const materialized = materializeGetterCalls(cb.arrow.body, knownGetterNames);
+  const predJSON = serializeParsedExpr2(materialized);
+  if (predJSON === null)
+    return null;
+  const paramName = cb.arrow.params[0] ?? "_";
+  const freeVars = freeVarsInBody2(materialized, new Set(cb.arrow.params));
+  return { propName, predJSON, paramName, freeVars };
+}
+function filterArmEarlierSiblingRefs(ctx, memo, signals, propsParams) {
+  if (!memo.parsed)
+    return [];
+  const match = matchFilterArmMemo(ctx, memo.parsed, signals, propsParams);
+  if (!match)
+    return [];
+  const memos = ctx.state.currentMemos ?? [];
+  const currentIndex = memos.findIndex((m) => m.name === memo.name);
+  if (currentIndex < 0)
+    return [];
+  const refs = [];
+  for (const name of match.freeVars) {
+    const idx = memos.findIndex((m) => m.name === name);
+    if (idx >= 0 && idx < currentIndex)
+      refs.push(name);
+  }
+  return refs;
+}
 function computeMemoInitialValue(ctx, memo, signals, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS2, goType) {
-  const resolved = computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars);
+  const resolved = computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars, new Set([memo.name]));
   if (resolved !== null)
     return resolved;
   if (goType === "bool")
@@ -1422,15 +1491,79 @@ function computeMemoInitialValue(ctx, memo, signals, propsParams, propFallbackVa
   }
   return "0";
 }
-function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallbackVars) {
+function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallbackVars, currentMemoName, resolving = new Set) {
   const propRef = (propName) => {
     const hoisted = propFallbackVars.get(propName);
     if (hoisted)
       return hoisted.varName;
     return `in.${capitalizeFieldName(propName)}`;
   };
-  const getterCallName = (e) => e.kind === "call" && e.callee.kind === "identifier" && e.args.length === 0 ? e.callee.name : null;
-  const propsMemberName = (e) => e.kind === "member" && !e.computed && e.object.kind === "identifier" && e.object.name === "props" ? e.property : null;
+  const envGetKey = (e) => {
+    if (e.kind !== "call" || e.callee.kind !== "member" || e.callee.computed)
+      return null;
+    const recvName = getterCallName(e.callee.object);
+    if (recvName === null)
+      return null;
+    const reader = ctx.state.envSignalReadersByLocal.get(recvName);
+    if (!reader || !reader.methods.has(e.callee.property))
+      return null;
+    const arg = e.args[0];
+    if (!arg || arg.kind !== "literal" || arg.literalType !== "string")
+      return null;
+    return { key: String(arg.value), fieldName: capitalizeFieldName(reader.canonicalName) };
+  };
+  {
+    const m = envGetKey(body);
+    if (m !== null)
+      return `in.${m.fieldName}.Get(${JSON.stringify(m.key)})`;
+  }
+  if (body.kind === "logical" && (body.op === "??" || body.op === "||") && body.right.kind === "literal" && body.right.literalType === "string") {
+    const m = envGetKey(body.left);
+    if (m !== null) {
+      const def = JSON.stringify(String(body.right.value));
+      return `func() string { if v := in.${m.fieldName}.Get(${JSON.stringify(m.key)}); v != "" { return v }; return ${def} }()`;
+    }
+  }
+  {
+    const match = matchFilterArmMemo(ctx, body, signals, propsParams);
+    if (match) {
+      const { propName, predJSON, paramName, freeVars } = match;
+      const currentIndex = (ctx.state.currentMemos ?? []).findIndex((m) => m.name === currentMemoName);
+      const envEntries = [];
+      let unresolved = false;
+      for (const name of freeVars) {
+        let goExpr = null;
+        const siblingIndex = (ctx.state.currentMemos ?? []).findIndex((m) => m.name === name);
+        if (siblingIndex >= 0) {
+          const siblingMemo = ctx.state.currentMemos[siblingIndex];
+          const eligible = currentIndex >= 0 && siblingIndex < currentIndex && !resolving.has(siblingMemo.name);
+          if (eligible) {
+            const hoisted = ctx.state.hoistedMemoLocals.get(siblingMemo.name);
+            goExpr = hoisted ?? computeMemoInitialValueOrNull(ctx, siblingMemo, signals, propsParams, propFallbackVars, new Set([...resolving, siblingMemo.name]));
+          }
+        } else {
+          const sig = signals.find((s) => s.getter === name);
+          if (sig) {
+            goExpr = getSignalInitialValueAsGo(ctx, sig.initialValue, propsParams, propFallbackVars);
+          } else {
+            const p = propsParams.find((pp) => pp.name === name);
+            if (p)
+              goExpr = propRef(name);
+          }
+        }
+        if (goExpr === null) {
+          unresolved = true;
+          break;
+        }
+        envEntries.push(`${JSON.stringify(name)}: ${goExpr}`);
+      }
+      if (!unresolved) {
+        const itemsField = `in.${capitalizeFieldName(propName)}`;
+        const envMap = `map[string]any{${envEntries.join(", ")}}`;
+        return `bf.FilterEval(${itemsField}, "${escapeGoString(predJSON)}", ${JSON.stringify(paramName)}, ${envMap})`;
+      }
+    }
+  }
   if (body.kind === "binary" && ["===", "!==", "==", "!="].includes(body.op) && body.right.kind === "literal" && body.right.literalType === "string") {
     const depName = getterCallName(body.left);
     if (depName) {
@@ -1469,8 +1602,8 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
           condGo = getSignalInitialValueAsGo(ctx, condSignal.initialValue, propsParams, propFallbackVars);
         } else {
           const condMemo = (ctx.state.currentMemos ?? []).find((m) => m.name === condName);
-          if (condMemo) {
-            condGo = computeMemoInitialValueOrNull(ctx, condMemo, signals, propsParams, propFallbackVars);
+          if (condMemo && !resolving.has(condMemo.name)) {
+            condGo = computeMemoInitialValueOrNull(ctx, condMemo, signals, propsParams, propFallbackVars, new Set([...resolving, condMemo.name]));
           }
         }
         if (condGo === "true")
@@ -1544,17 +1677,17 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
   }
   return null;
 }
-function computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS2) {
+function computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS2, resolving = new Set) {
   const computation = memo.computation;
   const tmplMemo = computeTemplateLiteralMemoInitialValue(ctx, memo, propsParams);
   if (tmplMemo !== null)
     return tmplMemo;
   if (memo.parsed) {
-    const fromParsed = memoInitialFromParsedBody(ctx, memo.parsed, signals, propsParams, propFallbackVars);
+    const fromParsed = memoInitialFromParsedBody(ctx, memo.parsed, signals, propsParams, propFallbackVars, memo.name, resolving);
     if (fromParsed !== null)
       return fromParsed;
   }
-  const cmpTernary = computeComparisonTernaryGo(ctx, memo.parsed, signals, propsParams, propFallbackVars);
+  const cmpTernary = computeComparisonTernaryGo(ctx, memo.parsed, signals, propsParams, propFallbackVars, resolving);
   if (cmpTernary !== null)
     return cmpTernary;
   const blockReturn = resolveBlockBodyMemoModuleConst(ctx, memo, signals);
@@ -1566,20 +1699,22 @@ function computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFall
     return objMemo;
   return null;
 }
-function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVars) {
+function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVars, resolving = new Set) {
   const signal = signals.find((s) => s.getter === name);
   if (signal) {
     return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars);
   }
   const memo = (ctx.state.currentMemos ?? []).find((m) => m.name === name);
   if (memo) {
+    if (resolving.has(memo.name))
+      return null;
     const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, "");
     const fb = ctx.extractPropFallback(stripped);
     if (fb && capitalizeFieldName(fb.propName) === capitalizeFieldName(memo.name)) {
       const field = `in.${capitalizeFieldName(fb.propName)}`;
       return `func() interface{} { v := interface{}(${field}); if v == nil || v == "" { return ${fb.goFallback} }; return v }()`;
     }
-    return computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars);
+    return computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars, new Set([...resolving, memo.name]));
   }
   const param = propsParams.find((p) => p.name === name);
   if (param) {
@@ -1588,7 +1723,7 @@ function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVar
   }
   return null;
 }
-function computeComparisonTernaryGo(ctx, parsed, signals, propsParams, propFallbackVars) {
+function computeComparisonTernaryGo(ctx, parsed, signals, propsParams, propFallbackVars, resolving = new Set) {
   if (!parsed || parsed.kind !== "conditional")
     return null;
   const cond = parsed.test;
@@ -1613,16 +1748,16 @@ function computeComparisonTernaryGo(ctx, parsed, signals, propsParams, propFallb
   const f = branch(parsed.alternate);
   if (t === null || f === null)
     return null;
-  const condGo = resolveComparisonOperandGo(ctx, cond.left, signals, propsParams, propFallbackVars);
+  const condGo = resolveComparisonOperandGo(ctx, cond.left, signals, propsParams, propFallbackVars, resolving);
   if (condGo === null)
     return null;
   const eqBranch = isEq ? t : f;
   const neBranch = isEq ? f : t;
   return `func() string { if ${condGo} == ${JSON.stringify(cond.right.value)} { return ${eqBranch} }; return ${neBranch} }()`;
 }
-function resolveComparisonOperandGo(ctx, node, signals, propsParams, propFallbackVars) {
+function resolveComparisonOperandGo(ctx, node, signals, propsParams, propFallbackVars, resolving = new Set) {
   if (node.kind === "call" && node.callee.kind === "identifier" && node.args.length === 0) {
-    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars);
+    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars, resolving);
   }
   if (node.kind === "logical" && node.op === "??" && node.right.kind === "literal" && node.right.literalType === "string") {
     const propName = propsAccessNameFromParsed2(ctx, node.left);
@@ -2001,7 +2136,18 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.currentMemos = ir.metadata.memos ?? [];
     this.state.currentTypeDefinitions = ir.metadata.typeDefinitions ?? [];
     this.state.contextConsumers = collectContextConsumers(ir.metadata);
-    this.state.searchParamsLocals = searchParamsLocalNames(ir.metadata);
+    this.state.ssrSeedPlan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata);
+    this.state.envSignalReadersByLocal = new Map;
+    this.state.searchParamsLocals = new Set;
+    for (const step of this.state.ssrSeedPlan.steps) {
+      if (step.kind !== "env-reader")
+        continue;
+      const reader = envSignalReaderFor(step.reader.key);
+      if (reader)
+        this.state.envSignalReadersByLocal.set(step.name, reader);
+      if (step.reader.key === "search")
+        this.state.searchParamsLocals.add(step.name);
+    }
     this.state.loweringMatchers = prepareLoweringMatchers(ir.metadata);
     augmentInheritedPropAccesses(ir);
   }
@@ -2505,6 +2651,28 @@ ${goFields.join(`
     if (propFallbackVars.size > 0)
       lines.push("");
     this.emitDynamicBodyWrappers(lines, ir, componentName, dynamicWithBody, propFallbackVars, emittedWrapperVars);
+    const memoPropsParamMap = new Map(ir.metadata.propsParams.map((p) => [p.name, p]));
+    this.state.hoistedMemoLocals = new Map;
+    const hoistNames = new Set;
+    for (const memo of ir.metadata.memos) {
+      for (const name of filterArmEarlierSiblingRefs(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams)) {
+        hoistNames.add(name);
+      }
+    }
+    if (hoistNames.size > 0) {
+      for (const memo of ir.metadata.memos) {
+        if (!hoistNames.has(memo.name))
+          continue;
+        const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap);
+        const value = computeMemoInitialValue(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType);
+        let localName = `memo${capitalizeFieldName(memo.name)}`;
+        while (GO_KEYWORDS.has(localName))
+          localName += "_";
+        lines.push(`	var ${localName} ${goType} = ${value}`);
+        this.state.hoistedMemoLocals.set(memo.name, localName);
+      }
+      lines.push("");
+    }
     lines.push(`	return ${propsTypeName}{`);
     lines.push("\t\tScopeID: scopeID,");
     lines.push("\t\tBfParent: in.BfParent,");
@@ -2578,11 +2746,15 @@ ${goFields.join(`
         continue;
       lines.push(`		${nested.name}s: ${varName},`);
     }
-    const memoPropsParamMap = new Map(ir.metadata.propsParams.map((p) => [p.name, p]));
     for (const memo of ir.metadata.memos) {
       const fieldName = capitalizeFieldName(memo.name);
       if (propFieldNames.has(fieldName))
         continue;
+      const hoistedLocal = this.state.hoistedMemoLocals.get(memo.name);
+      if (hoistedLocal) {
+        lines.push(`		${fieldName}: ${hoistedLocal},`);
+        continue;
+      }
       const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap);
       const memoValue = computeMemoInitialValue(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType);
       lines.push(`		${fieldName}: ${memoValue},`);
@@ -3271,12 +3443,14 @@ ${goFields.join(`
       }
       const memo = memos.find((m) => m.name === getterName);
       if (memo) {
-        return computeMemoInitialValueOrNull(this.emitCtx, memo, signals, propsParams);
+        return computeMemoInitialValueOrNull(this.emitCtx, memo, signals, propsParams, undefined, new Set([memo.name]));
       }
     }
     return null;
   }
   inferMemoType(memo, signals, propsParamMap) {
+    if (isListFilterMemo(memo))
+      return "[]any";
     if (memo.bodyIsTemplateLiteral)
       return "string";
     if (memo.computation.includes("*") || memo.computation.includes("/") || memo.computation.includes("+") || memo.computation.includes("-")) {
@@ -3798,7 +3972,7 @@ ${goFields.join(`
     "some"
   ]);
   higherOrderShapeOf(node) {
-    const cb = asCallbackMethodCall(node);
+    const cb = asCallbackMethodCall3(node);
     if (!cb)
       return null;
     if (!GoTemplateAdapter.PREDICATE_METHODS.has(cb.method))
@@ -3873,6 +4047,12 @@ ${goFields.join(`
         return evalForm;
       return this.pushCallbackBF101(method, true);
     }
+    if (method === "map") {
+      const evalForm = emitMapEval(recv, body, params[0] ?? "_", emit);
+      if (evalForm !== null)
+        return evalForm;
+      return this.pushCallbackBF101(method, true);
+    }
     return this.pushCallbackBF101(method, true);
   }
   arrayMethod(method, object, args, emit) {
@@ -4226,6 +4406,9 @@ ${goFields.join(`
         if (expr.callee.kind === "identifier" && expr.args.length === 0) {
           return `$.${capitalizeFieldName(expr.callee.name)}`;
         }
+        if (asCallbackMethodCall3(expr) !== null) {
+          return this.refuseFilterExprNode(expr);
+        }
         const result = this.renderFilterExpr(expr.callee, param, localVarMap);
         if (this.filterExprUnsupported)
           return "false";
@@ -4290,21 +4473,23 @@ ${goFields.join(`
         }
         return `or (${left}) (${right})`;
       }
-      default: {
-        this.filterExprUnsupported = true;
-        this.state.errors.push({
-          code: "BF101",
-          severity: "error",
-          message: `Filter predicate contains an expression that cannot be lowered to a Go template action: ${exprToString(expr)}`,
-          loc: this.makeLoc(),
-          suggestion: {
-            message: "Options:\n1. Use /* @client */ for client-side evaluation\n2. Rewrite the predicate to avoid nested higher-order methods (`.filter()` / `.map()` / etc. inside the predicate body)"
-          }
-        });
-        return "false";
-      }
+      default:
+        return this.refuseFilterExprNode(expr);
     }
   }
+  refuseFilterExprNode(expr) {
+    this.filterExprUnsupported = true;
+    this.state.errors.push({
+      code: "BF101",
+      severity: "error",
+      message: `Filter predicate contains an expression that cannot be lowered to a Go template action: ${exprToString(expr)}`,
+      loc: this.makeLoc(),
+      suggestion: {
+        message: "Options:\n1. Use /* @client */ for client-side evaluation\n2. Rewrite the predicate to avoid nested higher-order methods (`.filter()` / `.map()` / etc. inside the predicate body)"
+      }
+    });
+    return "false";
+  }
   isGoFunctionCall(expr) {
     switch (expr.kind) {
       case "binary":
@@ -4558,7 +4743,7 @@ ${goFields.join(`
           });
           return plain("false");
         }
-        if (asCallbackMethodCall(expr)) {
+        if (asCallbackMethodCall3(expr)) {
           const rendered = this.renderParsedExpr(expr);
           const split = this.splitPreamble(rendered);
           if (split)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "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.17.0"
+    "@barefootjs/shared": "0.17.1"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -57,6 +57,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.17.0"
+    "@barefootjs/jsx": "0.17.1"
   }
 }