@barefootjs/test 0.5.3 → 0.6.1

package/dist/index.js

@@ -190459,15 +190459,7 @@ var UNSUPPORTED_METHODS = new Set([
   "some",
   "forEach",
   "flatMap",
-  "flat",
-  "split",
-  "startsWith",
-  "endsWith",
-  "replace",
   "replaceAll",
-  "repeat",
-  "padStart",
-  "padEnd",
   "charAt",
   "charCodeAt",
   "codePointAt",
@@ -190478,6 +190470,15 @@ 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",
+  "lastIndexOf",
+  "concat"
+]);
 function parseExpression(expr) {
   const trimmed = expr.trim();
   if (!trimmed) {
@@ -190538,7 +190539,7 @@ function convertNode(node, raw) {
       }
     }
     if (callee.kind === "member" && !callee.computed) {
-      if (callee.property === "join" && args.length === 1) {
+      if (callee.property === "join") {
         return { kind: "array-method", method: "join", object: callee.object, args };
       }
       if (callee.property === "includes" && args.length === 1) {
@@ -190547,27 +190548,103 @@ function convertNode(node, raw) {
       if ((callee.property === "indexOf" || callee.property === "lastIndexOf") && args.length === 1) {
         return { kind: "array-method", method: callee.property, object: callee.object, args };
       }
-      if (callee.property === "at" && args.length === 1) {
+      if (callee.property === "at") {
         return { kind: "array-method", method: "at", object: callee.object, args };
       }
-      if (callee.property === "concat" && args.length === 1) {
+      if (callee.property === "concat" && args.length <= 1) {
         return { kind: "array-method", method: "concat", object: callee.object, args };
       }
-      if (callee.property === "slice" && (args.length === 1 || args.length === 2)) {
+      if (callee.property === "slice") {
         return { kind: "array-method", method: "slice", object: callee.object, args };
       }
-      if ((callee.property === "reverse" || callee.property === "toReversed") && args.length === 0) {
+      if (callee.property === "reverse" || callee.property === "toReversed") {
         return { kind: "array-method", method: callee.property, object: callee.object, args };
       }
-      if (callee.property === "toLowerCase" && args.length === 0) {
+      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 };
       }
-      if (callee.property === "toUpperCase" && args.length === 0) {
+      if (callee.property === "toUpperCase") {
         return { kind: "array-method", method: "toUpperCase", object: callee.object, args };
       }
-      if (callee.property === "trim" && args.length === 0) {
+      if (callee.property === "trim") {
         return { kind: "array-method", method: "trim", object: callee.object, args };
       }
+      if (callee.property === "split") {
+        return { kind: "array-method", method: "split", object: callee.object, args };
+      }
+      if (LOWERED_ARRAY_METHODS.has(callee.property)) {
+        const argName = callee.property === "concat" ? "other" : "x";
+        const detail = callee.property === "concat" ? "the variadic `.concat(a, b, …)` form" : `\`.${callee.property}(…)\` with ${args.length} argument(s)`;
+        return {
+          kind: "unsupported",
+          raw,
+          reason: `${detail} is not yet lowered to the Go/Mojo template adapters. Use the single-argument \`.${callee.property}(${argName})\` form, or pre-compute the value before the template.`
+        };
+      }
+      if (callee.property === "startsWith" || callee.property === "endsWith") {
+        if (args.length === 0) {
+          return {
+            kind: "unsupported",
+            raw,
+            reason: `\`.${callee.property}()\` with no search string is not lowered — JS coerces the missing argument to the string "undefined", a degenerate result. Pass an explicit search string, or pre-compute the value before the template.`
+          };
+        }
+        return { kind: "array-method", method: callee.property, object: callee.object, args };
+      }
+      if (callee.property === "replace") {
+        if (args.length < 2) {
+          return {
+            kind: "unsupported",
+            raw,
+            reason: `\`.replace(${args.length === 0 ? "" : "pattern"})\` needs both a pattern and a replacement — JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`
+          };
+        }
+        const patternNode = node.arguments[0];
+        if (patternNode && import_typescript8.default.isRegularExpressionLiteral(patternNode)) {
+          return {
+            kind: "unsupported",
+            raw,
+            reason: "String.prototype.replace supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */"
+          };
+        }
+        const badArg = args[0].kind === "unsupported" ? args[0] : args[1].kind === "unsupported" ? args[1] : undefined;
+        if (badArg && badArg.kind === "unsupported") {
+          return { kind: "unsupported", raw, reason: badArg.reason };
+        }
+        return { kind: "array-method", method: "replace", object: callee.object, args };
+      }
+      if (callee.property === "repeat") {
+        return { kind: "array-method", method: "repeat", object: callee.object, args };
+      }
+      if (callee.property === "padStart" || callee.property === "padEnd") {
+        return { kind: "array-method", method: callee.property, object: callee.object, args };
+      }
       if ((callee.property === "sort" || callee.property === "toSorted") && node.arguments.length === 1) {
         const comparator = extractSortComparatorFromTS(node.arguments[0], callee.property);
         if (comparator) {
@@ -190592,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 };
   }
@@ -190910,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) {
@@ -191218,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":
@@ -191338,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).`
           };
         }
       }

package/package.json

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