@barefootjs/test 0.6.0 → 0.7.0

package/dist/index.js

@@ -190459,7 +190459,6 @@ var UNSUPPORTED_METHODS = new Set([
   "some",
   "forEach",
   "flatMap",
-  "flat",
   "replaceAll",
   "charAt",
   "charCodeAt",
@@ -190471,6 +190470,9 @@ var UNSUPPORTED_METHODS = new Set([
   "matchAll",
   "search"
 ]);
+var UNSUPPORTED_METHOD_REASONS = {
+  forEach: `'.forEach()' returns undefined and has no template-position meaning. ` + `Use it for side effects inside an event handler or createEffect callback ` + `(client JS), or use '.map(...)' if you meant to render each item.`
+};
 var LOWERED_ARRAY_METHODS = new Set([
   "includes",
   "indexOf",
@@ -190558,6 +190560,32 @@ function convertNode(node, raw) {
       if (callee.property === "reverse" || callee.property === "toReversed") {
         return { kind: "array-method", method: callee.property, object: callee.object, args };
       }
+      if (callee.property === "flat") {
+        const depthNode = node.arguments[0];
+        let flatDepth;
+        if (depthNode === undefined) {
+          flatDepth = 1;
+        } else if (import_typescript8.default.isIdentifier(depthNode) && depthNode.text === "Infinity") {
+          flatDepth = "infinity";
+        } else {
+          let n;
+          if (import_typescript8.default.isNumericLiteral(depthNode)) {
+            n = Number(depthNode.text);
+          } else if (import_typescript8.default.isPrefixUnaryExpression(depthNode) && depthNode.operator === import_typescript8.default.SyntaxKind.MinusToken && import_typescript8.default.isNumericLiteral(depthNode.operand)) {
+            n = -Number(depthNode.operand.text);
+          }
+          if (n === undefined || Number.isNaN(n)) {
+            return {
+              kind: "unsupported",
+              raw,
+              reason: `\`.flat(depth)\` needs a literal integer or \`Infinity\` depth — a computed depth can't be resolved at template time. Use a literal depth, or pre-compute the value before the template.`
+            };
+          }
+          const truncated = Math.trunc(n);
+          flatDepth = truncated < 0 ? 0 : truncated;
+        }
+        return { kind: "array-method", method: "flat", object: callee.object, args: [], flatDepth };
+      }
       if (callee.property === "toLowerCase") {
         return { kind: "array-method", method: "toLowerCase", object: callee.object, args };
       }
@@ -190641,6 +190669,50 @@ function convertNode(node, raw) {
 ` + `(reverse the operands for descending order). ` + `Wrap the call in /* @client */ to evaluate at hydration.`
         };
       }
+      if ((callee.property === "reduce" || callee.property === "reduceRight") && node.arguments.length === 2) {
+        const reduceOp = extractReduceOpFromTS(node.arguments[0], node.arguments[1]);
+        if (reduceOp) {
+          return {
+            kind: "array-method",
+            method: callee.property,
+            object: callee.object,
+            args: [],
+            reduceOp
+          };
+        }
+        const m = callee.property;
+        return {
+          kind: "unsupported",
+          raw,
+          reason: `Reduce shape not supported. Accepted (arithmetic fold, explicit init):
+` + `  arr.${m}((acc, x) => acc + x, 0)
+` + `  arr.${m}((acc, x) => acc + x.field, 0)
+` + `  arr.${m}((acc, x) => acc * x.field, 1)
+` + `  arr.${m}((acc, x) => acc + x.field, '')   (string concat)
+` + `The accumulator must be the left operand and the initial ` + `value a number / string literal. ` + `Wrap the call in /* @client */ to evaluate at hydration.`
+        };
+      }
+      if (callee.property === "flatMap") {
+        const flatMapOp = node.arguments.length === 1 ? extractFlatMapOpFromTS(node.arguments[0]) : null;
+        if (flatMapOp) {
+          return {
+            kind: "array-method",
+            method: "flatMap",
+            object: callee.object,
+            args: [],
+            flatMapOp
+          };
+        }
+        return {
+          kind: "unsupported",
+          raw,
+          reason: `flatMap shape not supported. Accepted (self / field leaves, no thisArg):
+` + `  arr.flatMap(i => i)          (flatten one level)
+` + `  arr.flatMap(i => i.field)    (flatten a per-item array field)
+` + `  arr.flatMap(i => [i.a, i.b]) (gather per-item fields)
+` + `Richer callbacks (computed / nested access, arithmetic, calls, ` + `literal elements) and the 2-arg \`flatMap(fn, thisArg)\` form ` + `aren't lowered. Wrap the call in /* @client */ to evaluate at hydration.`
+        };
+      }
     }
     return { kind: "call", callee, args };
   }
@@ -190959,6 +191031,119 @@ function classifySortOperand(expr, paramA, paramB) {
   }
   return null;
 }
+function extractReduceOpFromTS(reducerNode, initNode) {
+  const init = classifyReduceInit(initNode);
+  if (!init)
+    return null;
+  if (!import_typescript8.default.isArrowFunction(reducerNode) && !import_typescript8.default.isFunctionExpression(reducerNode))
+    return null;
+  if (reducerNode.parameters.length !== 2)
+    return null;
+  const pAcc = reducerNode.parameters[0];
+  const pItem = reducerNode.parameters[1];
+  if (!import_typescript8.default.isIdentifier(pAcc.name) || !import_typescript8.default.isIdentifier(pItem.name))
+    return null;
+  const paramAcc = pAcc.name.text;
+  const paramItem = pItem.name.text;
+  let body;
+  if (import_typescript8.default.isArrowFunction(reducerNode) && !import_typescript8.default.isBlock(reducerNode.body)) {
+    body = reducerNode.body;
+  } else {
+    const block = reducerNode.body;
+    const stmts = block.statements;
+    if (stmts.length !== 1 || !import_typescript8.default.isReturnStatement(stmts[0]) || !stmts[0].expression)
+      return null;
+    body = stmts[0].expression;
+  }
+  const raw = body.getText();
+  const expr = unwrapParens(body);
+  if (!import_typescript8.default.isBinaryExpression(expr))
+    return null;
+  let op;
+  if (expr.operatorToken.kind === import_typescript8.default.SyntaxKind.PlusToken)
+    op = "+";
+  else if (expr.operatorToken.kind === import_typescript8.default.SyntaxKind.AsteriskToken)
+    op = "*";
+  else
+    return null;
+  const left = unwrapParens(expr.left);
+  if (!import_typescript8.default.isIdentifier(left) || left.text !== paramAcc)
+    return null;
+  const key = classifyReduceKey(unwrapParens(expr.right), paramItem);
+  if (!key)
+    return null;
+  const type2 = init.type;
+  if (type2 === "string" && op !== "+")
+    return null;
+  return { op, key, type: type2, init: init.value, raw, paramAcc, paramItem };
+}
+function extractFlatMapOpFromTS(cbNode) {
+  if (!import_typescript8.default.isArrowFunction(cbNode) && !import_typescript8.default.isFunctionExpression(cbNode))
+    return null;
+  if (cbNode.parameters.length !== 1)
+    return null;
+  const p = cbNode.parameters[0];
+  if (!import_typescript8.default.isIdentifier(p.name))
+    return null;
+  const param = p.name.text;
+  let body;
+  if (import_typescript8.default.isArrowFunction(cbNode) && !import_typescript8.default.isBlock(cbNode.body)) {
+    body = cbNode.body;
+  } else {
+    const block = cbNode.body;
+    const stmts = block.statements;
+    if (stmts.length !== 1 || !import_typescript8.default.isReturnStatement(stmts[0]) || !stmts[0].expression)
+      return null;
+    body = stmts[0].expression;
+  }
+  const raw = body.getText();
+  const inner = unwrapParens(body);
+  if (import_typescript8.default.isArrayLiteralExpression(inner)) {
+    if (inner.elements.length === 0)
+      return null;
+    const elements = [];
+    for (const el of inner.elements) {
+      if (import_typescript8.default.isSpreadElement(el) || import_typescript8.default.isOmittedExpression(el))
+        return null;
+      const leaf2 = classifyReduceKey(unwrapParens(el), param);
+      if (!leaf2)
+        return null;
+      elements.push(leaf2);
+    }
+    return { projection: { kind: "tuple", elements }, param, raw };
+  }
+  const leaf = classifyReduceKey(inner, param);
+  if (!leaf)
+    return null;
+  return { projection: leaf, param, raw };
+}
+function classifyReduceKey(expr, paramItem) {
+  if (import_typescript8.default.isIdentifier(expr)) {
+    return expr.text === paramItem ? { kind: "self" } : null;
+  }
+  if (import_typescript8.default.isPropertyAccessExpression(expr) && import_typescript8.default.isIdentifier(expr.expression)) {
+    if (expr.expression.text === paramItem)
+      return { kind: "field", field: expr.name.text };
+  }
+  return null;
+}
+function classifyReduceInit(node) {
+  let n = unwrapParens(node);
+  if (import_typescript8.default.isPrefixUnaryExpression(n) && n.operator === import_typescript8.default.SyntaxKind.MinusToken) {
+    if (import_typescript8.default.isNumericLiteral(n.operand))
+      return { type: "numeric", value: "-" + n.operand.text };
+    return null;
+  }
+  if (import_typescript8.default.isNumericLiteral(n))
+    return { type: "numeric", value: n.text };
+  if (import_typescript8.default.isStringLiteral(n)) {
+    const raw = n.getText();
+    if (raw.length < 2 || raw.slice(1, -1) !== n.text)
+      return null;
+    return { type: "string", value: n.text };
+  }
+  return null;
+}
 function collectDestructureBindings(pattern, pathPrefix, fieldMap, raw, excludedTopKeys) {
   let restName;
   for (const el of pattern.elements) {
@@ -191267,6 +191452,15 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
         if (e.method === "sort" || e.method === "toSorted") {
           return { kind: "array-method", method: e.method, object: walk(e.object), args: [], comparator: e.comparator };
         }
+        if (e.method === "reduce" || e.method === "reduceRight") {
+          return { kind: "array-method", method: e.method, object: walk(e.object), args: [], reduceOp: e.reduceOp };
+        }
+        if (e.method === "flat") {
+          return { kind: "array-method", method: "flat", object: walk(e.object), args: [], flatDepth: e.flatDepth };
+        }
+        if (e.method === "flatMap") {
+          return { kind: "array-method", method: "flatMap", object: walk(e.object), args: [], flatMapOp: e.flatMapOp };
+        }
         return { kind: "array-method", method: e.method, object: walk(e.object), args: e.args.map(walk) };
       case "literal":
       case "unsupported":
@@ -191387,7 +191581,8 @@ function checkSupport(expr) {
           return {
             supported: false,
             level: "L5_UNSUPPORTED",
-            reason: `Method '${methodName}()' has no template lowering and requires client-side evaluation. Wrap the expression in /* @client */ to defer it to hydration, or pre-compute the value before rendering.`
+            selfContained: true,
+            reason: UNSUPPORTED_METHOD_REASONS[methodName] ?? `'${methodName}()' can't render on the server. Pre-compute the value, or add /* @client */ for client-only (no SSR).`
           };
         }
       }
@@ -192387,6 +192582,7 @@ function transformComponentElement(node, ctx, name) {
     children,
     template: name.toLowerCase(),
     slotId,
+    ...isDynamicTagLocal(name, ctx) ? { dynamicTag: true } : {},
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
   };
 }
@@ -192402,6 +192598,7 @@ function transformSelfClosingComponent(node, ctx, name) {
     children: [],
     template: name.toLowerCase(),
     slotId,
+    ...isDynamicTagLocal(name, ctx) ? { dynamicTag: true } : {},
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
   };
 }
@@ -194094,6 +194291,40 @@ function findLocalConst(name, ctx) {
   const pool = fnScoped.length > 0 ? fnScoped : matches;
   return pool[pool.length - 1];
 }
+function isDynamicTagLocal(name, ctx) {
+  if (!hasDynamicTagBinding(name, ctx.sourceFile))
+    return false;
+  const a = ctx.analyzer;
+  if (a.jsxConstants?.has(name))
+    return false;
+  if (a.jsxFunctions?.has(name))
+    return false;
+  if (a.jsxMultiReturnFunctions?.has(name))
+    return false;
+  if (a.inlineableJsxConsts?.has(name))
+    return false;
+  return true;
+}
+function hasDynamicTagBinding(name, sourceFile) {
+  let found = false;
+  const visit2 = (node) => {
+    if (found)
+      return;
+    if (import_typescript11.default.isVariableDeclaration(node) && import_typescript11.default.isIdentifier(node.name) && node.name.text === name && node.initializer) {
+      let init = node.initializer;
+      while (import_typescript11.default.isAsExpression(init) || import_typescript11.default.isSatisfiesExpression(init) || import_typescript11.default.isParenthesizedExpression(init) || import_typescript11.default.isNonNullExpression(init)) {
+        init = init.expression;
+      }
+      if (import_typescript11.default.isPropertyAccessExpression(init) && init.name.text === "tag") {
+        found = true;
+        return;
+      }
+    }
+    import_typescript11.default.forEachChild(node, visit2);
+  };
+  visit2(sourceFile);
+  return found;
+}
 function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
   const constInfo = findLocalConst(ident.text, ctx);
   if (!constInfo)

package/package.json

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