@barefootjs/test 0.32.0 → 0.33.1

package/dist/index.js

@@ -187454,7 +187454,7 @@ function convertNode(node, raw) {
           }
           if (n === undefined || Number.isNaN(n)) {
             const parsedDepth = convertNode(depthNode, raw);
-            if (checkSupport(parsedDepth).supported) {
+            if (checkSupport(parsedDepth, "rendered").supported) {
               depthExpr = parsedDepth;
               flatDepth = 1;
             } else {
@@ -187548,10 +187548,12 @@ function convertNode(node, raw) {
         const k = objectLiteralKeyName(prop.name);
         if (k === null)
           return { kind: "unsupported", raw, reason: `Unsupported syntax: ${import_typescript.default.SyntaxKind[node.kind]}` };
-        properties.push({ key: k.key, keyKind: k.keyKind, shorthand: false, value: convertNode(prop.initializer, raw) });
+        properties.push({ kind: "prop", key: k.key, keyKind: k.keyKind, shorthand: false, value: convertNode(prop.initializer, raw) });
       } else if (import_typescript.default.isShorthandPropertyAssignment(prop)) {
         const key = prop.name.text;
-        properties.push({ key, keyKind: "identifier", shorthand: true, value: { kind: "identifier", name: key } });
+        properties.push({ kind: "prop", key, keyKind: "identifier", shorthand: true, value: { kind: "identifier", name: key } });
+      } else if (import_typescript.default.isSpreadAssignment(prop)) {
+        properties.push({ kind: "spread", expr: convertNode(prop.expression, raw) });
       } else {
         return { kind: "unsupported", raw, reason: `Unsupported syntax: ${import_typescript.default.SyntaxKind[node.kind]}` };
       }
@@ -188231,14 +188233,23 @@ function getUnaryOperatorString(op) {
   }
 }
 function isSupported(expr) {
-  return checkSupport(expr);
+  return checkSupport(expr, "rendered");
 }
-function checkSupport(expr) {
+function checkSupport(expr, pos) {
   switch (expr.kind) {
     case "unsupported":
       return { supported: false, reason: expr.reason };
-    case "object-literal":
-      return { supported: false, reason: "Unsupported syntax: ObjectLiteralExpression" };
+    case "object-literal": {
+      if (pos !== "value") {
+        return { supported: false, reason: "Unsupported syntax: ObjectLiteralExpression" };
+      }
+      for (const prop of expr.properties) {
+        const propSupport = checkSupport(prop.kind === "spread" ? prop.expr : prop.value, pos);
+        if (!propSupport.supported)
+          return propSupport;
+      }
+      return { supported: true, level: "L2" };
+    }
     case "identifier":
       return { supported: true, level: "L1" };
     case "literal":
@@ -188248,7 +188259,7 @@ function checkSupport(expr) {
       return { supported: false, reason: "Standalone arrow functions / regex literals are not supported" };
     case "array-literal": {
       for (const el of expr.elements) {
-        const elSupport = checkSupport(el);
+        const elSupport = checkSupport(el, pos);
         if (!elSupport.supported)
           return elSupport;
       }
@@ -188261,16 +188272,16 @@ function checkSupport(expr) {
           reason: `String.prototype.${expr.method} supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */`
         };
       }
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported)
         return objSupport;
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg);
+        const argSupport = checkSupport(arg, pos);
         if (!argSupport.supported)
           return argSupport;
       }
       if (expr.method === "flat" && expr.depthExpr) {
-        const depthSupport = checkSupport(expr.depthExpr);
+        const depthSupport = checkSupport(expr.depthExpr, pos);
         if (!depthSupport.supported)
           return depthSupport;
       }
@@ -188279,10 +188290,10 @@ function checkSupport(expr) {
     case "call": {
       const cb = asCallbackMethodCall(expr);
       if (cb) {
-        const objSupport = checkSupport(cb.object);
+        const objSupport = checkSupport(cb.object, pos);
         if (!objSupport.supported)
           return objSupport;
-        const bodySupport = checkSupport(cb.arrow.body);
+        const bodySupport = checkSupport(cb.arrow.body, pos);
         if (!bodySupport.supported) {
           return {
             supported: false,
@@ -188291,13 +188302,13 @@ function checkSupport(expr) {
           };
         }
         for (const rest of cb.args) {
-          const restSupport = checkSupport(rest);
+          const restSupport = checkSupport(rest, pos);
           if (!restSupport.supported)
             return restSupport;
         }
         return { supported: true, level: "L5" };
       }
-      const calleeSupport = checkSupport(expr.callee);
+      const calleeSupport = checkSupport(expr.callee, pos);
       if (!calleeSupport.supported) {
         return calleeSupport;
       }
@@ -188316,7 +188327,7 @@ function checkSupport(expr) {
         return { supported: true, level: "L1" };
       }
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg);
+        const argSupport = checkSupport(arg, pos);
         if (!argSupport.supported) {
           return argSupport;
         }
@@ -188324,7 +188335,7 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "member": {
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported) {
         return objSupport;
       }
@@ -188334,19 +188345,19 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "index-access": {
-      const objSupport = checkSupport(expr.object);
+      const objSupport = checkSupport(expr.object, pos);
       if (!objSupport.supported)
         return objSupport;
-      const indexSupport = checkSupport(expr.index);
+      const indexSupport = checkSupport(expr.index, pos);
       if (!indexSupport.supported)
         return indexSupport;
       return { supported: true, level: "L2" };
     }
     case "binary": {
-      const leftSupport = checkSupport(expr.left);
+      const leftSupport = checkSupport(expr.left, pos);
       if (!leftSupport.supported)
         return leftSupport;
-      const rightSupport = checkSupport(expr.right);
+      const rightSupport = checkSupport(expr.right, pos);
       if (!rightSupport.supported)
         return rightSupport;
       if (["===", "==", "!==", "!=", ">", "<", ">=", "<="].includes(expr.op)) {
@@ -188358,7 +188369,7 @@ function checkSupport(expr) {
       return { supported: false, reason: `Unknown operator: ${expr.op}` };
     }
     case "unary": {
-      const argSupport = checkSupport(expr.argument);
+      const argSupport = checkSupport(expr.argument, pos);
       if (!argSupport.supported)
         return argSupport;
       if (expr.op === "!") {
@@ -188370,25 +188381,25 @@ function checkSupport(expr) {
       return { supported: false, reason: `Unsupported unary operator: ${expr.op}` };
     }
     case "logical": {
-      const leftSupport = checkSupport(expr.left);
+      const leftSupport = checkSupport(expr.left, pos);
       if (!leftSupport.supported)
         return leftSupport;
       if (expr.op === "??" && expr.right.kind === "object-literal" && expr.right.properties.length === 0) {
         return { supported: true, level: "L4" };
       }
-      const rightSupport = checkSupport(expr.right);
+      const rightSupport = checkSupport(expr.right, pos);
       if (!rightSupport.supported)
         return rightSupport;
       return { supported: true, level: "L4" };
     }
     case "conditional": {
-      const testSupport = checkSupport(expr.test);
+      const testSupport = checkSupport(expr.test, pos);
       if (!testSupport.supported)
         return testSupport;
-      const consSupport = checkSupport(expr.consequent);
+      const consSupport = checkSupport(expr.consequent, pos);
       if (!consSupport.supported)
         return consSupport;
-      const altSupport = checkSupport(expr.alternate);
+      const altSupport = checkSupport(expr.alternate, pos);
       if (!altSupport.supported)
         return altSupport;
       return { supported: true, level: "L4" };
@@ -188396,7 +188407,7 @@ function checkSupport(expr) {
     case "template-literal": {
       for (const part of expr.parts) {
         if (part.type === "expression") {
-          const partSupport = checkSupport(part.expr);
+          const partSupport = checkSupport(part.expr, pos);
           if (!partSupport.supported)
             return partSupport;
         }
@@ -188521,7 +188532,7 @@ function isPureInit(e, pureCallNames) {
     case "array-literal":
       return e.elements.every(pure);
     case "object-literal":
-      return e.properties.every((p) => pure(p.value));
+      return e.properties.every((p) => pure(p.kind === "spread" ? p.expr : p.value));
     case "call":
       return e.callee.kind === "identifier" && e.args.length === 0 && pureCallNames !== undefined && pureCallNames.has(e.callee.name);
     case "array-method":
@@ -188575,7 +188586,7 @@ function usesPerPath(name, expr) {
         }
         return add(walk(e.object), sum(e.args));
       case "object-literal":
-        return sum(e.properties.map((p) => p.value));
+        return sum(e.properties.map((p) => p.kind === "spread" ? p.expr : p.value));
       case "arrow":
         return walk(e.body).max > 0 ? { min: 0, max: Number.POSITIVE_INFINITY } : { min: 0, max: 0 };
     }
@@ -188641,7 +188652,7 @@ function inlineBinding(expr, name, value) {
       case "object-literal":
         return {
           kind: "object-literal",
-          properties: e.properties.map((p) => ({ ...p, value: walk(p.value, enclosing) })),
+          properties: e.properties.map((p) => p.kind === "spread" ? { ...p, expr: walk(p.expr, enclosing) } : { ...p, value: walk(p.value, enclosing) }),
           raw: e.raw
         };
       case "literal":
@@ -190085,6 +190096,7 @@ var ErrorCodes = {
   MISSING_KEY_IN_LIST: "BF023",
   MISSING_KEY_IN_NESTED_LIST: "BF024",
   UNSUPPORTED_DESTRUCTURE_REST: "BF025",
+  RETURN_VALUE_NOT_JSX: "BF027",
   PROPS_DESTRUCTURING: "BF043",
   SIGNAL_GETTER_NOT_CALLED: "BF044",
   JSX_IN_LOCAL_FUNCTION: "BF045",
@@ -190116,6 +190128,7 @@ var errorMessages = {
   [ErrorCodes.MISSING_KEY_IN_LIST]: "Missing key attribute in list rendering. Add a key prop for efficient updates",
   [ErrorCodes.MISSING_KEY_IN_NESTED_LIST]: "Nested .map() loop requires key attribute for event delegation. Add a key prop to elements in the inner loop",
   [ErrorCodes.UNSUPPORTED_DESTRUCTURE_REST]: "Computed property key in .map() callback destructure is not supported. Rewrite the callback to destructure explicit bindings (e.g., `({ a, b }) => ...`) so the compiler can rewrite references to per-item signal accessors.",
+  [ErrorCodes.RETURN_VALUE_NOT_JSX]: "Component's return value is not recognized as JSX — return the JSX expression directly instead of binding it to a local variable first.",
   [ErrorCodes.PROPS_DESTRUCTURING]: "Props destructuring in function parameters breaks reactivity. Use props object directly.",
   [ErrorCodes.SIGNAL_GETTER_NOT_CALLED]: "Signal/memo getter passed without calling it. Use getter() to read the value.",
   [ErrorCodes.JSX_IN_LOCAL_FUNCTION]: "Local function returns JSX but cannot be inlined. Extract it as a top-level PascalCase component or use a single return statement.",
@@ -190685,6 +190698,14 @@ function visitComponentBody(node, ctx) {
     }
   }
   if (isTopLevel && (import_typescript9.default.isTryStatement(node) || import_typescript9.default.isSwitchStatement(node) || import_typescript9.default.isForStatement(node) || import_typescript9.default.isForInStatement(node) || import_typescript9.default.isForOfStatement(node) || import_typescript9.default.isWhileStatement(node) || import_typescript9.default.isDoStatement(node) || import_typescript9.default.isThrowStatement(node) || import_typescript9.default.isBlock(node) && node.parent === ctx.componentBodyBlock)) {
+    if (import_typescript9.default.isBlock(node)) {
+      const returnedLocal = findBlockBodyReturnedJsxLocalName(node);
+      if (returnedLocal) {
+        ctx.errors.push(createError(ErrorCodes.RETURN_VALUE_NOT_JSX, getSourceLocation(node, ctx.sourceFile, ctx.filePath), {
+          message: `Component '${ctx.componentName ?? "(unknown)"}' return value is not recognized ` + `as JSX — return the JSX expression directly instead of binding it to a local ` + `variable first (\`return ${returnedLocal}\` after \`const ${returnedLocal} = ` + `<jsx/>\` is not resolved at return position).`
+        }));
+      }
+    }
     collectInitStatement(node, ctx);
     return;
   }
@@ -190720,6 +190741,31 @@ function unwrapJsxTransparent(expr) {
   }
   return current;
 }
+function findBlockBodyReturnedJsxLocalName(block) {
+  const stmts = block.statements;
+  const last = stmts[stmts.length - 1];
+  if (!last || !import_typescript9.default.isReturnStatement(last) || !last.expression)
+    return null;
+  const returned = unwrapJsxTransparent(last.expression);
+  if (!import_typescript9.default.isIdentifier(returned))
+    return null;
+  const name = returned.text;
+  for (const stmt of stmts) {
+    if (!import_typescript9.default.isVariableStatement(stmt))
+      continue;
+    for (const decl of stmt.declarationList.declarations) {
+      if (!import_typescript9.default.isIdentifier(decl.name) || decl.name.text !== name || !decl.initializer)
+        continue;
+      let init = decl.initializer;
+      while (import_typescript9.default.isParenthesizedExpression(init))
+        init = init.expression;
+      if (import_typescript9.default.isJsxElement(init) || import_typescript9.default.isJsxSelfClosingElement(init) || import_typescript9.default.isJsxFragment(init) || initializerShapeContainsJsx(init) || isMapLikeCallWithJsx(init)) {
+        return name;
+      }
+    }
+  }
+  return null;
+}
 function extractJsxFromExpression(expr) {
   const inner = unwrapJsxTransparent(expr);
   if (import_typescript9.default.isJsxElement(inner) || import_typescript9.default.isJsxFragment(inner) || import_typescript9.default.isJsxSelfClosingElement(inner)) {
@@ -194362,6 +194408,8 @@ function matchToLocaleDateStringCall(callee, args, metadata) {
   let tz = null;
   const probeOptions = {};
   for (const prop of options.properties) {
+    if (prop.kind === "spread")
+      return null;
     if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
       return null;
     const value = String(prop.value.value);
@@ -194934,8 +194982,14 @@ function buildIRRoot(analyzer) {
   }
   ctx.isRoot = false;
   const ir = transformJsxExpression(jsxReturn, ctx);
-  if (ir === null)
+  if (ir === null) {
+    if (import_typescript13.default.isIdentifier(jsxReturn) && (analyzer.jsxConstants.has(jsxReturn.text) || analyzer.inlineableJsxConsts.has(jsxReturn.text))) {
+      analyzer.errors.push(createError(ErrorCodes.RETURN_VALUE_NOT_JSX, getSourceLocation(jsxReturn, analyzer.sourceFile, analyzer.filePath), {
+        message: `Component '${analyzer.componentName ?? "(unknown)"}' return value is not recognized ` + `as JSX — return the JSX expression directly instead of binding it to a local variable ` + `first (\`return ${jsxReturn.text}\` after \`const ${jsxReturn.text} = <jsx/>\` is not ` + `resolved at return position).`
+      }));
+    }
     return null;
+  }
   return wrapInScopeElement(ir);
 }
 function needsScopeWrapper(ir) {
@@ -196126,7 +196180,10 @@ function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_B
           ...e.method === "flat" && e.depthExpr ? { depthExpr: visit2(e.depthExpr, bound2) } : {}
         };
       case "object-literal":
-        return { ...e, properties: e.properties.map((p) => ({ ...p, value: visit2(p.value, bound2) })) };
+        return {
+          ...e,
+          properties: e.properties.map((p) => p.kind === "spread" ? { ...p, expr: visit2(p.expr, bound2) } : { ...p, value: visit2(p.value, bound2) })
+        };
       case "arrow": {
         const inner = e.params.length === 0 ? bound2 : new Set([...bound2, ...e.params]);
         return { ...e, body: visit2(e.body, inner) };
@@ -198047,6 +198104,35 @@ function getStringValue(node) {
   }
   return null;
 }
+function unwrapTransparentTsWrappers(node) {
+  let n = node;
+  while (import_typescript13.default.isParenthesizedExpression(n) || import_typescript13.default.isAsExpression(n) || import_typescript13.default.isSatisfiesExpression(n) || import_typescript13.default.isNonNullExpression(n)) {
+    n = n.expression;
+  }
+  return n;
+}
+function expressionWrapsJsx(node) {
+  const n = unwrapTransparentTsWrappers(node);
+  if (import_typescript13.default.isJsxElement(n) || import_typescript13.default.isJsxSelfClosingElement(n) || import_typescript13.default.isJsxFragment(n))
+    return true;
+  if (import_typescript13.default.isConditionalExpression(n)) {
+    return expressionWrapsJsx(n.whenTrue) || expressionWrapsJsx(n.whenFalse);
+  }
+  if (import_typescript13.default.isArrayLiteralExpression(n)) {
+    return n.elements.some((el) => expressionWrapsJsx(import_typescript13.default.isSpreadElement(el) ? el.expression : el));
+  }
+  return false;
+}
+function reportNakedJsxWrapperProp(ctx, attr, propName, jsxExpr) {
+  const shape = import_typescript13.default.isConditionalExpression(jsxExpr) ? "a ternary" : "an array literal";
+  ctx.analyzer.errors.push(createError(ErrorCodes.UNSUPPORTED_JSX_PATTERN, getSourceLocation(attr, ctx.sourceFile, ctx.filePath), {
+    message: `Prop '${propName}' is ${shape} wrapping JSX (${jsxExpr.getText(ctx.sourceFile)}). ` + `This shape is not compiled — only a JSX element/fragment given DIRECTLY as the prop value is.`,
+    suggestion: {
+      message: `Move the conditional/array out of the prop position: compute it in a local ` + `const and pass it as the component's children instead of a named prop ` + `(e.g. const ${propName} = ${jsxExpr.getText(ctx.sourceFile)}; <Comp>{${propName}}</Comp>). ` + `Wrapping the ternary/array in a fragment at the prop position ` + `(${propName}={<>{${jsxExpr.getText(ctx.sourceFile)}}</>}) is NOT a safe escape here: it compiles, ` + `but the child's own reactive prop getter receives the branch's HTML unbranded and re-escapes it as ` + `text on the child's very next reactive run, corrupting the DOM (a narrower gap #2651's door ` + `inventory left open — tracked separately).`,
+      escape: [{ kind: "rewrite" }]
+    }
+  }));
+}
 function processComponentProps(attributes, ctx) {
   const props = [];
   for (const attr of attributes.properties) {
@@ -198058,10 +198144,7 @@ function processComponentProps(attributes, ctx) {
       continue;
     const name = attr.name.getText(ctx.sourceFile);
     if (attr.initializer && import_typescript13.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
-      let jsxExpr = attr.initializer.expression;
-      while (import_typescript13.default.isParenthesizedExpression(jsxExpr)) {
-        jsxExpr = jsxExpr.expression;
-      }
+      const jsxExpr = unwrapTransparentTsWrappers(attr.initializer.expression);
       if (import_typescript13.default.isJsxElement(jsxExpr) || import_typescript13.default.isJsxSelfClosingElement(jsxExpr) || import_typescript13.default.isJsxFragment(jsxExpr)) {
         const prevInsideComponentChildren = ctx.insideComponentChildren;
         ctx.insideComponentChildren = true;
@@ -198076,6 +198159,10 @@ function processComponentProps(attributes, ctx) {
           continue;
         }
       }
+      if ((import_typescript13.default.isConditionalExpression(jsxExpr) || import_typescript13.default.isArrayLiteralExpression(jsxExpr)) && expressionWrapsJsx(jsxExpr)) {
+        reportNakedJsxWrapperProp(ctx, attr, name, jsxExpr);
+        continue;
+      }
     }
     let value = getAttributeValue(attr, ctx);
     if (value.kind === "template") {
@@ -199533,6 +199620,8 @@ function matchQueryHrefCall(callee, args, localNames) {
     return null;
   const triples = [];
   for (const p of obj.properties) {
+    if (p.kind === "spread")
+      return null;
     const v = p.value;
     if (v.kind === "conditional" && isOmitBranch(v.alternate)) {
       triples.push({ guard: v.test, key: p.key, value: v.consequent });
@@ -200241,6 +200330,8 @@ function resolveConstants(constants3) {
   for (const c of constants3) {
     if (c.parsed?.kind === "object-literal") {
       for (const prop of c.parsed.properties) {
+        if (prop.kind === "spread")
+          continue;
         const value2 = resolveObjectPropValue(prop.value, resolved);
         if (value2 !== null)
           resolved.set(`${c.name}.${prop.key}`, value2);

package/dist/resolve-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-constants.d.ts","sourceRoot":"","sources":["../src/resolve-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAAE,CAAC,GAChG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA0CrB"}
+{"version":3,"file":"resolve-constants.d.ts","sourceRoot":"","sources":["../src/resolve-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAAE,CAAC,GAChG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA6CrB"}

package/package.json

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

package/src/resolve-constants.ts

@@ -39,6 +39,9 @@ export function resolveConstants(
     // below (Copilot review, PR #2361).
     if (c.parsed?.kind === 'object-literal') {
       for (const prop of c.parsed.properties) {
+        // A spread (`{ ...t }`, #2696 Step 2) has no static `name.key`
+        // member path to expose — skip it, same as an unresolvable value.
+        if (prop.kind === 'spread') continue
         const value = resolveObjectPropValue(prop.value, resolved)
         if (value !== null) resolved.set(`${c.name}.${prop.key}`, value)
       }