@barefootjs/test 0.26.3 → 0.26.4

package/dist/index.js

@@ -196006,6 +196006,87 @@ function checkLoopKey(callback, ctx, isNested) {
     return;
   }
 }
+function flatMapProjectionCall(body) {
+  let expr;
+  if (import_typescript11.default.isBlock(body)) {
+    const real = body.statements;
+    if (real.length !== 1 || !import_typescript11.default.isReturnStatement(real[0]) || !real[0].expression)
+      return null;
+    expr = real[0].expression;
+  } else {
+    expr = body;
+  }
+  while (import_typescript11.default.isParenthesizedExpression(expr))
+    expr = expr.expression;
+  if (!import_typescript11.default.isCallExpression(expr))
+    return null;
+  if (!getMapLikeMethod(expr))
+    return null;
+  const cb = expr.arguments[0];
+  if (!cb || !import_typescript11.default.isArrowFunction(cb) && !import_typescript11.default.isFunctionExpression(cb))
+    return null;
+  for (const p of cb.parameters) {
+    if (!import_typescript11.default.isIdentifier(p.name))
+      return null;
+  }
+  let innerBody = cb.body;
+  if (import_typescript11.default.isBlock(innerBody)) {
+    const ret = innerBody.statements.find((s) => import_typescript11.default.isReturnStatement(s) && s.expression != null);
+    if (innerBody.statements.length !== 1 || !ret?.expression)
+      return null;
+    innerBody = ret.expression;
+  }
+  while (import_typescript11.default.isParenthesizedExpression(innerBody))
+    innerBody = innerBody.expression;
+  const isElementish = (n) => {
+    let m = n;
+    while (import_typescript11.default.isParenthesizedExpression(m))
+      m = m.expression;
+    if (import_typescript11.default.isJsxElement(m) || import_typescript11.default.isJsxSelfClosingElement(m))
+      return leafIsWirelessElement(m);
+    if (import_typescript11.default.isConditionalExpression(m))
+      return isElementish(m.whenTrue) && isElementish(m.whenFalse);
+    return false;
+  };
+  if (!isElementish(innerBody))
+    return null;
+  return expr;
+}
+function leafIsWirelessElement(el) {
+  let ok = true;
+  const visit2 = (n) => {
+    if (!ok)
+      return;
+    if (import_typescript11.default.isJsxOpeningElement(n) || import_typescript11.default.isJsxSelfClosingElement(n)) {
+      const tagNode = n.tagName;
+      const isIntrinsic = import_typescript11.default.isIdentifier(tagNode) ? !/^[A-Z]/.test(tagNode.text) : import_typescript11.default.isJsxNamespacedName(tagNode);
+      if (!isIntrinsic) {
+        ok = false;
+        return;
+      }
+      for (const attr of n.attributes.properties) {
+        if (import_typescript11.default.isJsxSpreadAttribute(attr)) {
+          ok = false;
+          return;
+        }
+        if (import_typescript11.default.isJsxAttribute(attr)) {
+          const name = attr.name.getText();
+          if (/^on[A-Z]/.test(name)) {
+            ok = false;
+            return;
+          }
+        }
+      }
+    }
+    if (import_typescript11.default.isCallExpression(n) && getMapLikeMethod(n) && containsJsxInExpression(n)) {
+      ok = false;
+      return;
+    }
+    import_typescript11.default.forEachChild(n, visit2);
+  };
+  visit2(el);
+  return ok;
+}
 function loopBodyIsMultiRoot(children) {
   const real = children.filter((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
   if (real.length === 0)
@@ -196051,6 +196132,7 @@ function extractItemConditionalKey(cond) {
 }
 function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const isNested = ctx.loopParams.size > 0;
+  const diagCountAtEntry = ctx.analyzer.errors.length;
   const depth = ctx.loopDepth;
   const propAccess = node.expression;
   const mapSource = propAccess.expression;
@@ -196337,12 +196419,34 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
           }
         }
       }
-      if (method === "flatMap" && children.length === 0) {
+      if (method === "flatMap" && children.length === 0 && !flatMapProjectionCall(body)) {
         flatMapCallback = buildFlatMapCallback(callback, body, ctx);
       }
     } else {
       tryTransformRenderableBody(body);
     }
+    if (method === "flatMap" && children.length === 0 && !flatMapCallback) {
+      const projection = flatMapProjectionCall(body);
+      if (projection) {
+        const transformed = transformJsxExpression(projection, ctx, isClientOnly);
+        if (transformed && transformed.type === "loop") {
+          children = [transformed];
+        }
+      }
+    }
+    if (method === "flatMap" && children.length === 0 && !flatMapCallback && !import_typescript11.default.isBlock(body)) {
+      flatMapCallback = buildFlatMapCallback(callback, body, ctx);
+    }
+    if (flatMapCallback)
+      preamble = undefined;
+    if (flatMapCallback && !isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("flatMap") ?? false)) {
+      ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(body, ctx.sourceFile, ctx.filePath), {
+        message: "A .flatMap() callback body with statements or a nested projection " + "cannot be lowered to a template on this backend.",
+        suggestion: {
+          message: "Add /* @client */ to render this loop on the client only"
+        }
+      }));
+    }
     if (paramBindings) {
       for (const b of paramBindings)
         ctx.loopParams.delete(b.name);
@@ -196354,6 +196458,16 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     ctx.loopDepth--;
   }
   if (children.length === 0 && !flatMapCallback) {
+    const cb = node.arguments[0];
+    const cbBody = cb && (import_typescript11.default.isArrowFunction(cb) || import_typescript11.default.isFunctionExpression(cb)) ? cb.body : undefined;
+    if (cbBody && containsJsxInExpression(cbBody) && ctx.analyzer.errors.length === diagCountAtEntry) {
+      ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(cbBody, ctx.sourceFile, ctx.filePath), {
+        message: `A .${method}() callback that builds JSX in this shape cannot be ` + "compiled — the JSX would leak verbatim into the client bundle. " + "Recognized bodies: a JSX element/fragment, a ternary or " + "&& / || / ?? expression, an array literal (flatMap), or a block " + "body whose return the compiler can lower.",
+        suggestion: {
+          message: "Restructure the callback to return the JSX element directly " + "(or via a block body with a plain `return`)."
+        }
+      }));
+    }
     return null;
   }
   if (import_typescript11.default.isArrowFunction(node.arguments[0]) && children.length > 0) {
@@ -196406,6 +196520,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const hasCalls = exprHasFunctionCalls(arrayExpr);
   const isDirectPropArray = method !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx);
   const isStaticArray = !isSignalOrMemoArray(array, ctx) && !isDirectPropArray && !hasCalls && !objectIteration;
+  const preambleRegions = preamble && !isStaticArray ? collectPreambleRegions(children, new Set(preamble.declaredNames), ctx) : undefined;
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -196436,6 +196551,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     depth,
     clientOnly: isClientOnly || undefined,
     preamble,
+    preambleRegions: preambleRegions && preambleRegions.length > 0 ? preambleRegions : undefined,
     paramType,
     indexType,
     paramBindings,
@@ -196498,6 +196614,28 @@ function buildFlatMapCallback(callback, body, ctx) {
     }));
     return;
   }
+  for (const leafIr of leafIrs) {
+    if (leafIr.type !== "element") {
+      const loc = "loc" in leafIr && leafIr.loc ? leafIr.loc : getSourceLocation(body, ctx.sourceFile, ctx.filePath);
+      ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, loc, {
+        message: "A JSX leaf produced by a .flatMap() callback must be a single " + "element — a fragment or non-element root cannot ride the keyed " + "descriptor path (each leaf hydrates and patches as one element).",
+        suggestion: {
+          message: "Wrap the leaf content in a single keyed element."
+        }
+      }));
+      return;
+    }
+    if (flatMapLeafNeedsWiring(leafIr)) {
+      const loc = "loc" in leafIr && leafIr.loc ? leafIr.loc : getSourceLocation(body, ctx.sourceFile, ctx.filePath);
+      ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, loc, {
+        message: "A JSX element produced by a .flatMap() callback cannot carry " + "event handlers, components, nested loops, or spreads — the " + "leaf renders as a keyed HTML string with no per-element wiring.",
+        suggestion: {
+          message: "Restructure so the interactive element lives in a .map() body — " + "the descriptor path has no per-element wiring on any backend, " + "so /* @client */ does not lift this."
+        }
+      }));
+      return;
+    }
+  }
   const pieces = reconstructAsSegments(body, ctx.sourceFile, ctx.analyzer.typeExcludeRanges, leafSpans);
   const segments = pieces.map((piece) => {
     if ("marker" in piece)
@@ -196512,6 +196650,25 @@ function buildFlatMapCallback(callback, body, ctx) {
     rawBody: tsxSourceText(body.getText(ctx.sourceFile))
   };
 }
+function flatMapLeafNeedsWiring(ir) {
+  switch (ir.type) {
+    case "component":
+    case "loop":
+      return true;
+    case "element":
+      if (ir.events.length > 0)
+        return true;
+      if (ir.attrs.some((a) => a.name.startsWith("...")))
+        return true;
+      return ir.children.some(flatMapLeafNeedsWiring);
+    case "conditional":
+      return flatMapLeafNeedsWiring(ir.whenTrue) || (ir.whenFalse ? flatMapLeafNeedsWiring(ir.whenFalse) : false);
+    case "fragment":
+      return ir.children.some(flatMapLeafNeedsWiring);
+    default:
+      return false;
+  }
+}
 function preambleFragmentNeedsWiring(ir) {
   switch (ir.type) {
     case "component":
@@ -196554,6 +196711,40 @@ function flagArrayChildExpressions(nodes, declared) {
     }
   }
 }
+function collectPreambleRegions(nodes, declared, ctx) {
+  const regions = [];
+  const visit2 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "expression": {
+          const refs = extractFreeIdentifiersFromText(node.expr);
+          const usesPreambleLocal = [...refs].some((r) => declared.has(r));
+          if (usesPreambleLocal) {
+            if (!node.slotId)
+              node.slotId = generateSlotId(ctx);
+            node.preambleRegion = true;
+            node.reactive = true;
+            regions.push({
+              slotId: node.slotId,
+              expr: node.expr,
+              joinArrayChild: node.joinArrayChild || undefined
+            });
+          }
+          break;
+        }
+        case "element":
+        case "fragment":
+          visit2(node.children);
+          break;
+        case "conditional":
+          visit2([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+      }
+    }
+  };
+  visit2(nodes);
+  return regions;
+}
 function collectBindingNames(name, out) {
   if (import_typescript11.default.isIdentifier(name)) {
     out.add(name.text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.26.3",
+  "version": "0.26.4",
   "description": "Test utilities for BarefootJS - IR-based component testing without a browser",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "directory": "packages/test"
   },
   "dependencies": {
-    "@barefootjs/jsx": "0.26.3"
+    "@barefootjs/jsx": "0.26.4"
   },
   "devDependencies": {
     "typescript": "^5.0.0"