@barefootjs/test 0.29.0 → 0.30.2

package/dist/index.js

@@ -189319,20 +189319,115 @@ var SKELETON_PATH_FORCE_CLOSE_GROUPS = [
 ];
 
 // ../jsx/src/prop-rewrite.ts
+function collectBindingNames(name, out) {
+  if (import_typescript5.default.isIdentifier(name)) {
+    out.add(name.text);
+    return;
+  }
+  for (const el of name.elements) {
+    if (import_typescript5.default.isBindingElement(el))
+      collectBindingNames(el.name, out);
+  }
+}
+function scopeFrameOf(n) {
+  if (import_typescript5.default.isFunctionLike(n)) {
+    const frame = new Set;
+    for (const p of n.parameters)
+      collectBindingNames(p.name, frame);
+    if ((import_typescript5.default.isFunctionExpression(n) || import_typescript5.default.isFunctionDeclaration(n)) && n.name)
+      frame.add(n.name.text);
+    return frame.size > 0 ? frame : null;
+  }
+  if (import_typescript5.default.isBlock(n)) {
+    const frame = new Set;
+    for (const st of n.statements) {
+      if (import_typescript5.default.isVariableStatement(st)) {
+        for (const d of st.declarationList.declarations)
+          collectBindingNames(d.name, frame);
+      } else if (import_typescript5.default.isFunctionDeclaration(st) && st.name) {
+        frame.add(st.name.text);
+      }
+    }
+    return frame.size > 0 ? frame : null;
+  }
+  if (import_typescript5.default.isCatchClause(n) && n.variableDeclaration) {
+    const frame = new Set;
+    collectBindingNames(n.variableDeclaration.name, frame);
+    return frame.size > 0 ? frame : null;
+  }
+  return null;
+}
+function walkWithScope(root, visit) {
+  const scopeStack = [];
+  const isShadowed = (name) => scopeStack.some((frame) => frame.has(name));
+  function rec(n, parent) {
+    const frame = scopeFrameOf(n);
+    if (frame)
+      scopeStack.push(frame);
+    if (import_typescript5.default.isIdentifier(n))
+      visit(n, parent, isShadowed(n.text));
+    import_typescript5.default.forEachChild(n, (child) => rec(child, n));
+    if (frame)
+      scopeStack.pop();
+  }
+  rec(root);
+}
+function isNonValuePosition(n, parent) {
+  if (!parent)
+    return false;
+  if (import_typescript5.default.isPropertyAssignment(parent) && parent.name === n)
+    return true;
+  if (import_typescript5.default.isPropertyAccessExpression(parent) && parent.name === n)
+    return true;
+  if (import_typescript5.default.isQualifiedName(parent) && parent.right === n)
+    return true;
+  if ((import_typescript5.default.isParameter(parent) || import_typescript5.default.isVariableDeclaration(parent) || import_typescript5.default.isBindingElement(parent)) && parent.name === n)
+    return true;
+  if (import_typescript5.default.isTypeReferenceNode(parent))
+    return true;
+  return false;
+}
 function collectAstPropRefs(node, propNames, out) {
-  function visit(n, parent) {
-    if (import_typescript5.default.isIdentifier(n) && propNames.has(n.text)) {
-      if (parent && import_typescript5.default.isPropertyAssignment(parent) && parent.name === n)
-        return;
-      if (parent && import_typescript5.default.isShorthandPropertyAssignment(parent) && parent.name === n)
-        return;
-      if (parent && import_typescript5.default.isPropertyAccessExpression(parent) && parent.name === n)
-        return;
-      out.add(n.text);
+  walkWithScope(node, (n, parent, shadowed) => {
+    if (shadowed || !propNames.has(n.text))
+      return;
+    if (parent && import_typescript5.default.isShorthandPropertyAssignment(parent) && parent.name === n)
+      return;
+    if (isNonValuePosition(n, parent))
+      return;
+    out.add(n.text);
+  });
+}
+function applyScopedPropRefRewrite(text, propRefs) {
+  const prefix = "(";
+  const sf = import_typescript5.default.createSourceFile("__bf_prop_rewrite.ts", `${prefix}${text}
+)`, import_typescript5.default.ScriptTarget.Latest, true);
+  const parseDiagnostics = sf.parseDiagnostics;
+  if (parseDiagnostics && parseDiagnostics.length > 0)
+    return null;
+  const edits = [];
+  walkWithScope(sf, (n, parent, shadowed) => {
+    if (shadowed || !propRefs.has(n.text))
+      return;
+    if (isNonValuePosition(n, parent))
+      return;
+    const start = n.getStart(sf) - prefix.length;
+    const end = n.getEnd() - prefix.length;
+    if (start < 0 || end > text.length)
+      return;
+    if (parent && import_typescript5.default.isShorthandPropertyAssignment(parent) && parent.name === n) {
+      edits.push({ start, end, replacement: `${n.text}: ${PROPS_PARAM}.${n.text}` });
+      return;
     }
-    import_typescript5.default.forEachChild(n, (child) => visit(child, n));
+    edits.push({ start, end, replacement: `${PROPS_PARAM}.${n.text}` });
+  });
+  if (edits.length === 0)
+    return text;
+  let result = text;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, edit.start) + edit.replacement + result.slice(edit.end);
   }
-  visit(node);
+  return result;
 }
 function applyRegexPropRefRewrite(text, propRefs) {
   const { protect, restore } = createTemplateAwareStringProtector();
@@ -189362,7 +189457,7 @@ function rewriteBarePropRefs(text, node, propNames, extraPropRefs) {
   }
   if (foundPropRefs.size === 0)
     return;
-  return applyRegexPropRefRewrite(text, foundPropRefs);
+  return applyScopedPropRefRewrite(text, foundPropRefs) ?? applyRegexPropRefRewrite(text, foundPropRefs);
 }
 
 // ../jsx/src/instrumentation.ts
@@ -189720,6 +189815,30 @@ function typeNodeToTypeInfo(typeNode, sourceFile, rawOf) {
   if (import_typescript7.default.isArrayTypeNode(typeNode)) {
     return { kind: "array", raw, elementType: recurse(typeNode.elementType) };
   }
+  if (import_typescript7.default.isLiteralTypeNode(typeNode)) {
+    const lit = typeNode.literal;
+    if (import_typescript7.default.isStringLiteral(lit) || import_typescript7.default.isNoSubstitutionTemplateLiteral(lit)) {
+      return { kind: "primitive", raw, primitive: "string", literalValue: lit.text };
+    }
+    if (import_typescript7.default.isNumericLiteral(lit)) {
+      return { kind: "primitive", raw, primitive: "number", literalValue: lit.text };
+    }
+    if (import_typescript7.default.isPrefixUnaryExpression(lit) && lit.operator === import_typescript7.default.SyntaxKind.MinusToken && import_typescript7.default.isNumericLiteral(lit.operand)) {
+      return { kind: "primitive", raw, primitive: "number", literalValue: `-${lit.operand.text}` };
+    }
+    if (lit.kind === import_typescript7.default.SyntaxKind.TrueKeyword || lit.kind === import_typescript7.default.SyntaxKind.FalseKeyword) {
+      return {
+        kind: "primitive",
+        raw,
+        primitive: "boolean",
+        literalValue: lit.kind === import_typescript7.default.SyntaxKind.TrueKeyword ? "true" : "false"
+      };
+    }
+    if (lit.kind === import_typescript7.default.SyntaxKind.NullKeyword) {
+      return { kind: "primitive", raw, primitive: "null" };
+    }
+    return { kind: "unknown", raw };
+  }
   if (import_typescript7.default.isUnionTypeNode(typeNode)) {
     return { kind: "union", raw, unionTypes: typeNode.types.map(recurse) };
   }
@@ -189909,9 +190028,7 @@ function baseTypeName(raw) {
   return (idx === -1 ? raw : raw.slice(0, idx)).trim();
 }
 function isNullishArm(t) {
-  if (t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined"))
-    return true;
-  return t.kind === "unknown" && (t.raw === "null" || t.raw === "undefined");
+  return t.kind === "primitive" && (t.primitive === "null" || t.primitive === "undefined");
 }
 function stripUnion(type2) {
   if (!type2 || type2.kind !== "union" || !type2.unionTypes)
@@ -190631,14 +190748,17 @@ function collectSignal(node, ctx) {
   const pattern = node.name;
   const callExpr = node.initializer;
   const elements = pattern.elements;
-  if (elements.length < 1 || elements.length > 2 || !import_typescript8.default.isBindingElement(elements[0]) || !import_typescript8.default.isIdentifier(elements[0].name)) {
+  const getterElided = elements.length === 2 && import_typescript8.default.isOmittedExpression(elements[0]);
+  if (elements.length < 1 || elements.length > 2 || !getterElided && (!import_typescript8.default.isBindingElement(elements[0]) || !import_typescript8.default.isIdentifier(elements[0].name))) {
     return;
   }
   if (elements.length === 2 && (!import_typescript8.default.isBindingElement(elements[1]) || !import_typescript8.default.isIdentifier(elements[1].name))) {
     return;
   }
-  const getter = elements[0].name.text;
   const setter = elements.length === 2 && import_typescript8.default.isBindingElement(elements[1]) && import_typescript8.default.isIdentifier(elements[1].name) ? elements[1].name.text : null;
+  if (getterElided && !setter)
+    return;
+  const getter = getterElided ? `__bfGet_${setter}` : elements[0].name.text;
   const initialValue = callExpr.arguments[0] ? ctx.getJS(callExpr.arguments[0]) : "";
   const typedInitialValue = callExpr.arguments[0] ? callExpr.arguments[0].getText(ctx.sourceFile) : undefined;
   let type2 = { kind: "unknown", raw: "unknown" };
@@ -190659,6 +190779,7 @@ function collectSignal(node, ctx) {
   ctx.signals.push({
     getter,
     setter,
+    getterElided: getterElided || undefined,
     initialValue,
     typedInitialValue: typedInitialValue !== initialValue ? typedInitialValue : undefined,
     templateInitialValue,
@@ -190849,9 +190970,17 @@ function collectMemo(node, ctx) {
   const blockBody = arrowNode && import_typescript8.default.isArrowFunction(arrowNode) && import_typescript8.default.isBlock(arrowNode.body) ? arrowNode.body : undefined;
   const parsedBlock = blockBody ? parseBlockBodyTolerant(blockBody, ctx.sourceFile, (node2) => ctx.getJS(node2)) : undefined;
   const parsedBlockComplete = parsedBlock && blockBody ? parsedBlock.length === blockBody.statements.length : undefined;
+  let templateComputation;
+  if (!ctx.propsObjectName && callExpr.arguments[0]) {
+    const propNames = new Set(ctx.propsParams.map((p) => p.name));
+    if (propNames.size > 0) {
+      templateComputation = rewriteBarePropRefs(computation, callExpr.arguments[0], propNames);
+    }
+  }
   ctx.memos.push({
     name,
     computation,
+    templateComputation,
     parsedBlock,
     parsedBlockComplete,
     typedComputation: typedComputation !== computation ? typedComputation : undefined,
@@ -193925,8 +194054,10 @@ function deriveFormat(locale, probeOptions) {
   return { pattern, names };
 }
 function unionMemberLiteral(member) {
-  const m = /^'([^'\\]*)'$|^"([^"\\]*)"$/.exec(member.raw.trim());
-  return m ? m[1] ?? m[2] : null;
+  if (member.kind === "primitive" && member.primitive === "string" && member.literalValue !== undefined) {
+    return member.literalValue;
+  }
+  return null;
 }
 function resolveLocaleUnionMembers(locale, metadata) {
   let sourcePropName = null;
@@ -194531,6 +194662,13 @@ function jsxToIR(analyzer) {
 function buildIRRoot(analyzer) {
   if (analyzer.conditionalReturns.length > 0) {
     const ctx2 = createTransformContext(analyzer);
+    const allReactiveNoLocals = analyzer.jsxReturn != null && analyzer.conditionalReturns.every((cr) => cr.scopeVariables.length === 0 && exprCallsReactiveGetters(cr.condition, ctx2));
+    if (allReactiveNoLocals) {
+      const chain = buildIfStatementChain(analyzer, ctx2, { asConditional: true });
+      if (!chain)
+        return null;
+      return chain.type === "conditional" ? wrapInScopeElement(chain) : chain;
+    }
     return buildIfStatementChain(analyzer, ctx2);
   }
   if (!analyzer.jsxReturn)
@@ -194686,11 +194824,52 @@ function transformJsxElement(node, ctx) {
   }
   return transformHtmlElement(node, ctx, tagName);
 }
+function lowerFormControlValueSsr(tagName, attrs, children) {
+  if (tagName !== "textarea" && tagName !== "select")
+    return;
+  const valueAttr = attrs.find((a) => a.name === "value");
+  if (!valueAttr || valueAttr.clientOnly || valueAttr.value.kind !== "expression")
+    return;
+  const { expr, templateExpr } = valueAttr.value;
+  valueAttr.clientOnly = true;
+  if (tagName === "textarea") {
+    if (children.length > 0)
+      return;
+    children.push({
+      type: "expression",
+      expr,
+      templateExpr: `escapeText(${templateExpr ?? expr})`,
+      typeInfo: null,
+      reactive: false,
+      slotId: null,
+      loc: valueAttr.loc,
+      origin: { phase: "ssr", scope: "template", effect: "pure" }
+    });
+    return;
+  }
+  const selectedFor = (optValue) => AttrValueOf.expression(`(${expr}) === ${JSON.stringify(optValue)}`, templateExpr !== undefined ? { templateExpr: `(${templateExpr}) === ${JSON.stringify(optValue)}` } : undefined);
+  const distribute = (nodes) => {
+    for (const n of nodes) {
+      if (n.type === "element" && n.tag === "option") {
+        if (n.attrs.some((a) => a.name === "selected"))
+          continue;
+        const optValue = n.attrs.find((a) => a.name === "value");
+        if (!optValue || optValue.value.kind !== "literal")
+          continue;
+        n.attrs.push({ name: "selected", value: selectedFor(optValue.value.value), loc: n.loc });
+      } else if (n.type === "fragment" || n.type === "element" && n.tag === "optgroup") {
+        distribute(n.children);
+      }
+    }
+  };
+  distribute(children);
+}
 function transformHtmlElement(node, ctx, tagName) {
   const { attrs, events, ref } = processAttributes(node.openingElement.attributes, ctx);
   const needsScope = ctx.isRoot;
   ctx.isRoot = false;
   const children = transformChildren(node.children, ctx);
+  lowerFormControlValueSsr(tagName, attrs, children);
   const needsSlot = events.length > 0 || hasDynamicContent(children) || hasReactiveAttributes(attrs, ctx) || ref !== null;
   const slotId = needsSlot ? generateSlotId(ctx) : null;
   if (slotId) {
@@ -194722,6 +194901,8 @@ function transformSelfClosingElement(node, ctx) {
     return transformSelfClosingComponent(node, ctx, resolved ?? tagName);
   }
   const { attrs, events, ref } = processAttributes(node.attributes, ctx);
+  const selfClosingChildren = [];
+  lowerFormControlValueSsr(tagName, attrs, selfClosingChildren);
   const needsSlot = events.length > 0 || hasReactiveAttributes(attrs, ctx) || ref !== null;
   const slotId = needsSlot ? generateSlotId(ctx) : null;
   const needsScope = ctx.isRoot;
@@ -194732,7 +194913,7 @@ function transformSelfClosingElement(node, ctx) {
     attrs,
     events,
     ref,
-    children: [],
+    children: selfClosingChildren,
     slotId,
     needsScope,
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
@@ -196115,6 +196296,15 @@ function branchHasNoElement(node) {
   }
   return true;
 }
+function tagLoopItemRootComponents(nodes) {
+  for (const node of nodes) {
+    if (node.type === "component") {
+      node.loopItemRoot = true;
+    } else if (node.type === "conditional") {
+      tagLoopItemRootComponents([node.whenTrue, node.whenFalse]);
+    }
+  }
+}
 function loopBodyItemConditional(children) {
   const real = children.filter((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
   if (real.length !== 1)
@@ -196352,9 +196542,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         const pre = multiReturn.preamble ?? [];
         if (pre.length > 0) {
           preamble = preambleFromValueStatements(pre, ctx);
-          if (!isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
+          if (!preamble.declarations && !isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
             ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, loc, {
-              message: "A .map() callback body with a `const`/`let` preamble before its " + "branches cannot be lowered to a template: the loop-local binding " + "cannot be carried into a conditional branch on this backend.",
+              message: "A .map() callback body with a preamble before its branches cannot be " + "lowered to a template: the preamble is not a sequence of value " + "declarations, so this backend has no per-row local to carry into the " + "branches.",
               suggestion: {
                 message: "Add /* @client */ to evaluate this expression on the client only"
               }
@@ -196421,6 +196611,14 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
           }
           if (valueStmts.length > 0) {
             preamble = preambleFromValueStatements(valueStmts, ctx);
+            if (!preamble.declarations && !isClientOnly && !(ctx.analyzer.acceptsCallbackBody?.("map") ?? false)) {
+              ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(body, ctx.sourceFile, ctx.filePath), {
+                message: "A .map() callback preamble that is not a sequence of value " + "declarations cannot be lowered to a template: this backend can " + "declare a per-row local, but cannot run arbitrary statements per row.",
+                suggestion: {
+                  message: "Add /* @client */ to evaluate this expression on the client only"
+                }
+              }));
+            }
           }
         }
       }
@@ -196506,6 +196704,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }));
     preamble = undefined;
   }
+  tagLoopItemRootComponents(children);
   let childComponent;
   if (children.length === 1 && children[0].type === "component") {
     const comp = children[0];
@@ -196526,6 +196725,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   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;
+  if (preamble && !isStaticArray) {
+    markPreambleAttrSlots(children, new Set(preamble.declaredNames), ctx);
+  }
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -196750,20 +196952,66 @@ function collectPreambleRegions(nodes, declared, ctx) {
   visit2(nodes);
   return regions;
 }
-function collectBindingNames(name, out) {
+function markPreambleAttrSlots(nodes, declared, ctx) {
+  const readsDeclared = (attr) => {
+    if (attr.name === "key")
+      return false;
+    const value = attr.value;
+    if (value.kind !== "expression" && value.kind !== "template")
+      return false;
+    const refs = attr.freeIdentifiers ?? extractFreeIdentifiersFromText(attrValueText(value));
+    for (const r of refs)
+      if (declared.has(r))
+        return true;
+    return false;
+  };
+  const visit2 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "element":
+          if (!node.slotId && node.attrs.some(readsDeclared))
+            node.slotId = generateSlotId(ctx);
+          visit2(node.children);
+          break;
+        case "fragment":
+          visit2(node.children);
+          break;
+        case "conditional":
+          visit2([node.whenTrue, ...node.whenFalse ? [node.whenFalse] : []]);
+          break;
+      }
+    }
+  };
+  visit2(nodes);
+}
+function attrValueText(value) {
+  if (value.kind === "expression")
+    return value.expr;
+  if (value.kind !== "template")
+    return "";
+  const out = [];
+  for (const p of value.parts) {
+    if (p.type === "ternary")
+      out.push(p.condition, p.whenTrue, p.whenFalse);
+    else if (p.type === "lookup")
+      out.push(p.key);
+  }
+  return out.join(" ");
+}
+function collectBindingNames2(name, out) {
   if (import_typescript11.default.isIdentifier(name)) {
     out.add(name.text);
     return;
   }
   for (const el of name.elements) {
     if (import_typescript11.default.isBindingElement(el))
-      collectBindingNames(el.name, out);
+      collectBindingNames2(el.name, out);
   }
 }
 function collectPreambleDeclaredNames(stmt, out) {
   if (import_typescript11.default.isVariableStatement(stmt)) {
     for (const decl of stmt.declarationList.declarations) {
-      collectBindingNames(decl.name, out);
+      collectBindingNames2(decl.name, out);
     }
   } else if (import_typescript11.default.isFunctionDeclaration(stmt) && stmt.name) {
     out.add(stmt.name.text);
@@ -196787,9 +197035,32 @@ function preambleFromValueStatements(statements, ctx) {
     segments: trimPreambleSegments(segments),
     ssrText: tsxSourceText(typedParts.join(" ")),
     declaredNames: [...declared],
-    builderNames: []
+    builderNames: [],
+    declarations: neutralPreambleDeclarations(statements, ctx) ?? undefined
   };
 }
+function neutralPreambleDeclarations(statements, ctx) {
+  const out = [];
+  for (const stmt of statements) {
+    if (!import_typescript11.default.isVariableStatement(stmt))
+      return null;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!import_typescript11.default.isIdentifier(decl.name))
+        return null;
+      if (!decl.initializer)
+        return null;
+      const valueParsed = tsNodeToParsedExpr(decl.initializer);
+      if (!isSupported(valueParsed).supported)
+        return null;
+      out.push({
+        name: decl.name.text,
+        valueParsed,
+        raw: decl.initializer.getText(ctx.sourceFile)
+      });
+    }
+  }
+  return out.length > 0 ? out : null;
+}
 function trimPreambleSegments(segments) {
   const last = segments[segments.length - 1];
   if (last?.kind === "js") {
@@ -197133,6 +197404,8 @@ function parseTemplateLiteral(expr, ctx) {
 }
 function tryResolveTemplateSpanFromConst(expr, ctx) {
   if (import_typescript11.default.isIdentifier(expr)) {
+    if (ctx.loopParams.has(expr.text))
+      return null;
     const constInfo = findLocalConst(expr.text, ctx.analyzer);
     if (!constInfo)
       return null;
@@ -197147,6 +197420,8 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
   if (import_typescript11.default.isElementAccessExpression(expr)) {
     if (!import_typescript11.default.isIdentifier(expr.expression))
       return null;
+    if (ctx.loopParams.has(expr.expression.text))
+      return null;
     const constInfo = findLocalConst(expr.expression.text, ctx.analyzer);
     if (!constInfo)
       return null;
@@ -197235,6 +197510,9 @@ function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
   if (import_typescript11.default.isNoSubstitutionTemplateLiteral(ast) || import_typescript11.default.isStringLiteral(ast)) {
     return [{ type: "string", value: ast.text }];
   }
+  if (import_typescript11.default.isElementAccessExpression(ast) && !import_typescript11.default.isStringLiteralLike(ast.argumentExpression) && !import_typescript11.default.isNumericLiteral(ast.argumentExpression)) {
+    return tryResolveTemplateSpanFromConst(ast, ctx);
+  }
   if (!import_typescript11.default.isTemplateExpression(ast))
     return null;
   let resolvedAny = false;
@@ -197482,8 +197760,11 @@ function processComponentProps(attributes, ctx) {
     }
     let value = getAttributeValue(attr, ctx);
     if (value.kind === "template") {
-      value = AttrValueOf.expression(templatePartsToJsString(value.parts), {
-        parts: value.parts
+      const collapsed = templatePartsToJsString(value.parts);
+      const collapsedTemplate = templatePartsToJsString(value.parts, { useTemplate: true });
+      value = AttrValueOf.expression(collapsed, {
+        parts: value.parts,
+        ...collapsedTemplate !== collapsed && { templateExpr: collapsedTemplate }
       });
     } else if (value.kind === "boolean-attr") {
       value = AttrValueOf.booleanShorthand();
@@ -197512,16 +197793,18 @@ function processComponentProps(attributes, ctx) {
   }
   return props;
 }
-function templatePartsToJsString(parts) {
+function templatePartsToJsString(parts, opts) {
   let result = "`";
   for (const part of parts) {
     if (part.type === "string") {
-      result += part.value;
+      result += opts?.useTemplate && part.templateValue ? part.templateValue : part.value;
     } else if (part.type === "ternary") {
-      result += `\${${part.condition} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
+      const cond = opts?.useTemplate && part.templateCondition ? part.templateCondition : part.condition;
+      result += `\${${cond} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
     } else if (part.type === "lookup") {
+      const key = opts?.useTemplate && part.templateKey ? part.templateKey : part.key;
       const obj = "{" + Object.entries(part.cases).map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`).join(", ") + "}";
-      result += `\${(${obj})[${part.key}]}`;
+      result += `\${(${obj})[${key}]}`;
     }
   }
   result += "`";
@@ -197732,11 +198015,12 @@ function replaceBranchLocalRefs(text, branchNames, resolve2) {
   const pattern = new RegExp(`(?<![\\w$])(${branchNames.join("|")})(?![\\w$])`, "g");
   return replaceInExprContexts(text, pattern, (_match, name) => resolve2(name));
 }
-function buildIfStatementChain(analyzer, ctx) {
+function buildIfStatementChain(analyzer, ctx, opts) {
   const conditionalReturns = analyzer.conditionalReturns;
+  const asConditional = opts?.asConditional === true;
   let alternate = null;
   if (analyzer.jsxReturn) {
-    ctx.isRoot = true;
+    ctx.isRoot = !asConditional;
     alternate = transformNode(analyzer.jsxReturn, ctx);
   }
   for (let i2 = conditionalReturns.length - 1;i2 >= 0; i2--) {
@@ -197805,7 +198089,7 @@ function buildIfStatementChain(analyzer, ctx) {
       ctx.getJS = substitutedGetJS;
       ctx.analyzer.getJS = substitutedGetJS;
     }
-    ctx.isRoot = true;
+    ctx.isRoot = !asConditional;
     let consequent;
     try {
       consequent = transformNode(condReturn.jsxReturn, ctx);
@@ -197835,6 +198119,27 @@ function buildIfStatementChain(analyzer, ctx) {
       }
     }
     const loc = getSourceLocation(condReturn.ifStatement, analyzer.sourceFile, analyzer.filePath);
+    if (asConditional && alternate) {
+      const conditional = {
+        type: "conditional",
+        condition,
+        templateCondition,
+        conditionType: null,
+        reactive: true,
+        whenTrue: consequent,
+        whenFalse: alternate,
+        slotId: generateSlotId(ctx),
+        loc,
+        origin: {
+          phase: "tick",
+          scope: "template",
+          effect: "pure",
+          freeRefs: resolveFreeRefs(condReturn.condition, makeBindingEnv(ctx))
+        }
+      };
+      alternate = conditional;
+      continue;
+    }
     const ifStmt = {
       type: "if-statement",
       condition,
@@ -198124,6 +198429,13 @@ function formatDateLocalNames(metadata) {
   return names;
 }
 
+// ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
+var import_typescript15 = __toESM(require_typescript(), 1);
+var NO_PREAMBLE = {
+  lazySafe: true,
+  facts: { declaredNames: new Set, freeNames: new Set }
+};
+
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-row-eligibility.ts
 var PURE_SOURCE_GLOBALS = new Set([
   "Object",
@@ -198168,7 +198480,7 @@ var INERT_BINDING_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-var import_typescript15 = __toESM(require_typescript(), 1);
+var import_typescript16 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts
 var NON_BUBBLING_EVENTS = new Set([
@@ -198183,7 +198495,7 @@ var NON_BUBBLING_EVENTS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-var import_typescript16 = __toESM(require_typescript(), 1);
+var import_typescript17 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ir-to-client-js/source-map.ts
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -198274,21 +198586,21 @@ class SourceMapGenerator {
 }
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-var import_typescript17 = __toESM(require_typescript(), 1);
+var import_typescript18 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/ssr-defaults.ts
-var import_typescript18 = __toESM(require_typescript(), 1);
+var import_typescript19 = __toESM(require_typescript(), 1);
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 
 // ../jsx/src/augment-inherited-props.ts
-var import_typescript19 = __toESM(require_typescript(), 1);
+var import_typescript20 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/rich-type-refusal.ts
 var EMPTY_BINDINGS2 = new Map;
 // ../jsx/src/shared-program.ts
 init_path();
-var import_typescript20 = __toESM(require_typescript(), 1);
+var import_typescript21 = __toESM(require_typescript(), 1);
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
   renderChildren(children) {
@@ -198827,9 +199139,9 @@ function registerBuiltinLoweringPlugins() {
     registerLoweringPlugin(plugin);
 }
 // ../jsx/src/combine-client-js.ts
-var import_typescript21 = __toESM(require_typescript(), 1);
-// ../jsx/src/debug.ts
 var import_typescript22 = __toESM(require_typescript(), 1);
+// ../jsx/src/debug.ts
+var import_typescript23 = __toESM(require_typescript(), 1);
 function escapeForIdBoundary(name) {
   return name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -198921,7 +199233,7 @@ function resolveSetters(handler, setterToSignal, fnSetters) {
   return refs;
 }
 // ../jsx/src/profiler.ts
-var import_typescript23 = __toESM(require_typescript(), 1);
+var import_typescript24 = __toESM(require_typescript(), 1);
 
 // ../jsx/src/index.ts
 registerBuiltinLoweringPlugins();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.29.0",
+  "version": "0.30.2",
   "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.29.0"
+    "@barefootjs/jsx": "0.30.2"
   },
   "devDependencies": {
     "typescript": "^5.0.0"