@barefootjs/test 0.4.0 → 0.5.1

package/dist/index.js

@@ -190546,6 +190546,8 @@ function convertNode(node, raw) {
 ` + `  (a, b) => a.field - b.field
 ` + `  (a, b) => a.localeCompare(b)
 ` + `  (a, b) => a.field.localeCompare(b.field)
+` + `  (a, b) => a.field > b.field ? 1 : -1   (relational ternary)
+` + `  any of the above ||-chained for multi-key tie-breaks
 ` + `(reverse the operands for descending order). ` + `Wrap the call in /* @client */ to evaluate at hydration.`
         };
       }
@@ -190705,26 +190707,54 @@ function extractSortComparatorFromTS(node, method) {
   const paramA = pA.name.text;
   const paramB = pB.name.text;
   let body;
-  if (import_typescript8.default.isArrowFunction(node)) {
-    if (import_typescript8.default.isBlock(node.body))
-      return null;
+  if (import_typescript8.default.isArrowFunction(node) && !import_typescript8.default.isBlock(node.body)) {
     body = node.body;
   } else {
-    const stmts = node.body.statements;
+    const block = node.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 keys = [];
+  for (const operand of flattenLogicalOr(body)) {
+    const key = classifyLeafComparator(operand, paramA, paramB);
+    if (!key)
+      return null;
+    keys.push(key);
+  }
+  if (keys.length === 0)
+    return null;
+  return { keys, raw, paramA, paramB, method };
+}
+function unwrapParens(expr) {
+  let e = expr;
+  while (import_typescript8.default.isParenthesizedExpression(e))
+    e = e.expression;
+  return e;
+}
+function flattenLogicalOr(expr) {
+  const inner = unwrapParens(expr);
+  if (import_typescript8.default.isBinaryExpression(inner) && inner.operatorToken.kind === import_typescript8.default.SyntaxKind.BarBarToken) {
+    return [...flattenLogicalOr(inner.left), ...flattenLogicalOr(inner.right)];
+  }
+  return [inner];
+}
+function classifyLeafComparator(expr, paramA, paramB) {
+  const body = unwrapParens(expr);
   if (import_typescript8.default.isBinaryExpression(body) && body.operatorToken.kind === import_typescript8.default.SyntaxKind.MinusToken) {
-    return classifyComparatorOperands(body.left, body.right, paramA, paramB, "numeric", method, raw);
+    return classifyComparatorOperands(body.left, body.right, paramA, paramB, "numeric");
   }
   if (import_typescript8.default.isCallExpression(body) && import_typescript8.default.isPropertyAccessExpression(body.expression) && body.expression.name.text === "localeCompare" && body.arguments.length === 1) {
-    return classifyComparatorOperands(body.expression.expression, body.arguments[0], paramA, paramB, "string", method, raw);
+    return classifyComparatorOperands(body.expression.expression, body.arguments[0], paramA, paramB, "string");
+  }
+  if (import_typescript8.default.isConditionalExpression(body)) {
+    return classifyTernaryComparator(body, paramA, paramB);
   }
   return null;
 }
-function classifyComparatorOperands(left, right, paramA, paramB, type2, method, raw) {
+function classifyComparatorOperands(left, right, paramA, paramB, type2) {
   const leftRef = classifySortOperand(left, paramA, paramB);
   const rightRef = classifySortOperand(right, paramA, paramB);
   if (!leftRef || !rightRef)
@@ -190737,15 +190767,89 @@ function classifyComparatorOperands(left, right, paramA, paramB, type2, method,
     return null;
   }
   const direction = leftRef.param === "A" ? "asc" : "desc";
-  return {
-    key: leftRef.key,
-    type: type2,
-    direction,
-    raw,
-    paramA,
-    paramB,
-    method
-  };
+  return { key: leftRef.key, type: type2, direction };
+}
+function classifyTernaryComparator(node, paramA, paramB) {
+  const cond = unwrapParens(node.condition);
+  if (import_typescript8.default.isBinaryExpression(cond) && (cond.operatorToken.kind === import_typescript8.default.SyntaxKind.EqualsEqualsEqualsToken || cond.operatorToken.kind === import_typescript8.default.SyntaxKind.EqualsEqualsToken) && sameKeyOperands(cond.left, cond.right, paramA, paramB) && numericSign(node.whenTrue) === 0) {
+    const elseBranch = unwrapParens(node.whenFalse);
+    if (import_typescript8.default.isConditionalExpression(elseBranch)) {
+      return classifyTernaryComparator(elseBranch, paramA, paramB);
+    }
+    return null;
+  }
+  if (!import_typescript8.default.isBinaryExpression(cond))
+    return null;
+  const op = cond.operatorToken.kind;
+  const isGreater = op === import_typescript8.default.SyntaxKind.GreaterThanToken || op === import_typescript8.default.SyntaxKind.GreaterThanEqualsToken;
+  const isLess = op === import_typescript8.default.SyntaxKind.LessThanToken || op === import_typescript8.default.SyntaxKind.LessThanEqualsToken;
+  if (!isGreater && !isLess)
+    return null;
+  const leftRef = classifySortOperand(cond.left, paramA, paramB);
+  const rightRef = classifySortOperand(cond.right, paramA, paramB);
+  if (!leftRef || !rightRef)
+    return null;
+  if (leftRef.param === rightRef.param)
+    return null;
+  if (leftRef.key.kind !== rightRef.key.kind)
+    return null;
+  if (leftRef.key.kind === "field" && rightRef.key.kind === "field" && leftRef.key.field !== rightRef.key.field) {
+    return null;
+  }
+  const trueSign = numericSign(node.whenTrue);
+  if (trueSign === null || trueSign === 0)
+    return null;
+  if (!isBoundedTernaryElse(node.whenFalse, leftRef.key, paramA, paramB))
+    return null;
+  const greaterForA = leftRef.param === "A" ? isGreater : !isGreater;
+  const asc = greaterForA ? trueSign > 0 : trueSign < 0;
+  return { key: leftRef.key, type: "auto", direction: asc ? "asc" : "desc" };
+}
+function sameKeyOperands(left, right, paramA, paramB) {
+  const l = classifySortOperand(left, paramA, paramB);
+  const r = classifySortOperand(right, paramA, paramB);
+  if (!l || !r)
+    return false;
+  if (l.param === r.param)
+    return false;
+  if (l.key.kind !== r.key.kind)
+    return false;
+  if (l.key.kind === "field" && r.key.kind === "field" && l.key.field !== r.key.field)
+    return false;
+  return true;
+}
+function numericSign(expr) {
+  const e = unwrapParens(expr);
+  if (import_typescript8.default.isPrefixUnaryExpression(e) && e.operator === import_typescript8.default.SyntaxKind.MinusToken) {
+    const inner = numericSign(e.operand);
+    return inner === null ? null : -inner;
+  }
+  if (import_typescript8.default.isNumericLiteral(e)) {
+    const n = Number(e.text);
+    if (Number.isNaN(n))
+      return null;
+    if (n === 0)
+      return 0;
+    return n > 0 ? 1 : -1;
+  }
+  return null;
+}
+function isBoundedTernaryElse(expr, key, paramA, paramB) {
+  const e = unwrapParens(expr);
+  if (numericSign(e) !== null)
+    return true;
+  if (import_typescript8.default.isConditionalExpression(e)) {
+    const nested = classifyTernaryComparator(e, paramA, paramB);
+    return nested !== null && sortKeyEquals(nested.key, key);
+  }
+  return false;
+}
+function sortKeyEquals(a, b) {
+  if (a.kind !== b.kind)
+    return false;
+  if (a.kind === "field" && b.kind === "field")
+    return a.field === b.field;
+  return true;
 }
 function classifySortOperand(expr, paramA, paramB) {
   if (import_typescript8.default.isIdentifier(expr)) {
@@ -192577,6 +192681,23 @@ function containsJsxInExpression(node) {
   }
   return import_typescript11.default.forEachChild(node, containsJsxInExpression) ?? false;
 }
+function callsJsxHelper(node, ctx) {
+  let found = false;
+  const visit2 = (n) => {
+    if (found)
+      return;
+    if (import_typescript11.default.isCallExpression(n) && import_typescript11.default.isIdentifier(n.expression)) {
+      const name = n.expression.text;
+      if (ctx.analyzer.jsxFunctions.has(name) || ctx.analyzer.jsxMultiReturnFunctions.has(name)) {
+        found = true;
+        return;
+      }
+    }
+    import_typescript11.default.forEachChild(n, visit2);
+  };
+  visit2(node);
+  return found;
+}
 function containsAwaitExpression(node) {
   if (import_typescript11.default.isAwaitExpression(node))
     return true;
@@ -192656,7 +192777,7 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
       if (node.operatorToken.kind === import_typescript11.default.SyntaxKind.AmpersandAmpersandToken) {
         return transformLogicalAnd(node, ctx);
       }
-      if ((node.operatorToken.kind === import_typescript11.default.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === import_typescript11.default.SyntaxKind.BarBarToken) && containsJsxInExpression(node.right)) {
+      if ((node.operatorToken.kind === import_typescript11.default.SyntaxKind.QuestionQuestionToken || node.operatorToken.kind === import_typescript11.default.SyntaxKind.BarBarToken) && (containsJsxInExpression(node.right) || callsJsxHelper(node.right, ctx))) {
         return transformNullishCoalescing(node, ctx);
       }
       return null;
@@ -193113,23 +193234,23 @@ function checkLoopKey(callback, ctx, isNested) {
   }
   while (import_typescript11.default.isParenthesizedExpression(body))
     body = body.expression;
+  function checkJsxOperand(node) {
+    let n = node;
+    while (import_typescript11.default.isParenthesizedExpression(n))
+      n = n.expression;
+    if (import_typescript11.default.isJsxElement(n))
+      checkOpening(n.openingElement);
+    else if (import_typescript11.default.isJsxSelfClosingElement(n))
+      checkOpening(n);
+  }
   if (import_typescript11.default.isConditionalExpression(body)) {
-    const whenTrue = body.whenTrue;
-    const whenFalse = body.whenFalse;
-    let wt = whenTrue;
-    let wf = whenFalse;
-    while (import_typescript11.default.isParenthesizedExpression(wt))
-      wt = wt.expression;
-    while (import_typescript11.default.isParenthesizedExpression(wf))
-      wf = wf.expression;
-    if (import_typescript11.default.isJsxElement(wt))
-      checkOpening(wt.openingElement);
-    else if (import_typescript11.default.isJsxSelfClosingElement(wt))
-      checkOpening(wt);
-    if (import_typescript11.default.isJsxElement(wf))
-      checkOpening(wf.openingElement);
-    else if (import_typescript11.default.isJsxSelfClosingElement(wf))
-      checkOpening(wf);
+    checkJsxOperand(body.whenTrue);
+    checkJsxOperand(body.whenFalse);
+    return;
+  }
+  if (import_typescript11.default.isBinaryExpression(body) && (body.operatorToken.kind === import_typescript11.default.SyntaxKind.AmpersandAmpersandToken || body.operatorToken.kind === import_typescript11.default.SyntaxKind.BarBarToken || body.operatorToken.kind === import_typescript11.default.SyntaxKind.QuestionQuestionToken)) {
+    checkJsxOperand(body.left);
+    checkJsxOperand(body.right);
     return;
   }
   if (import_typescript11.default.isJsxElement(body)) {
@@ -193152,6 +193273,38 @@ function loopBodyIsMultiRoot(children) {
     return false;
   return loopBodyIsMultiRoot(only.children);
 }
+function branchHasNoElement(node) {
+  if (node.type === "element" || node.type === "component")
+    return false;
+  if (node.type === "conditional") {
+    return branchHasNoElement(node.whenTrue) || branchHasNoElement(node.whenFalse);
+  }
+  if (node.type === "fragment") {
+    const real = node.children.filter((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
+    return real.length !== 1 || branchHasNoElement(real[0]);
+  }
+  return true;
+}
+function loopBodyItemConditional(children) {
+  const real = children.filter((c) => !(c.type === "text" && typeof c.value === "string" && !c.value.trim()));
+  if (real.length !== 1)
+    return null;
+  const only = real[0];
+  if (only.type !== "conditional")
+    return null;
+  if (branchHasNoElement(only.whenTrue) || branchHasNoElement(only.whenFalse)) {
+    return only;
+  }
+  return null;
+}
+function extractItemConditionalKey(cond) {
+  const a = branchHasNoElement(cond.whenTrue) ? null : extractLoopKey(cond.whenTrue);
+  const b = branchHasNoElement(cond.whenFalse) ? null : extractLoopKey(cond.whenFalse);
+  if (a !== null && b !== null) {
+    return normalizeKeyExpr(a) === normalizeKeyExpr(b) ? a : null;
+  }
+  return a ?? b;
+}
 function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const isNested = ctx.loopParams.size > 0;
   const propAccess = node.expression;
@@ -193314,6 +193467,19 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }
     if (index)
       ctx.loopParams.add(index);
+    const tryTransformRenderableBody = (expr) => {
+      if (!import_typescript11.default.isBinaryExpression(expr))
+        return;
+      const op = expr.operatorToken.kind;
+      if (op !== import_typescript11.default.SyntaxKind.AmpersandAmpersandToken && op !== import_typescript11.default.SyntaxKind.BarBarToken && op !== import_typescript11.default.SyntaxKind.QuestionQuestionToken) {
+        return;
+      }
+      if (!containsJsxInExpression(expr) && !callsJsxHelper(expr, ctx))
+        return;
+      const transformed = transformJsxExpression(expr, ctx, isClientOnly);
+      if (transformed)
+        children = [transformed];
+    };
     const body = callback.body;
     if (import_typescript11.default.isJsxElement(body) || import_typescript11.default.isJsxSelfClosingElement(body) || import_typescript11.default.isJsxFragment(body)) {
       const transformed = transformNode(body, ctx);
@@ -193336,6 +193502,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         children = [transformConditional(inner, ctx)];
       } else if (method === "flatMap" && import_typescript11.default.isArrayLiteralExpression(inner)) {
         children = transformArrayLiteralChildren(inner, ctx);
+      } else {
+        tryTransformRenderableBody(inner);
       }
     } else if (method === "flatMap" && import_typescript11.default.isArrayLiteralExpression(body)) {
       children = transformArrayLiteralChildren(body, ctx);
@@ -193384,6 +193552,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
       if (method === "flatMap" && children.length === 0) {
         flatMapCallback = buildFlatMapCallback(callback, body, ctx);
       }
+    } else {
+      tryTransformRenderableBody(body);
     }
     if (paramBindings) {
       for (const b of paramBindings)
@@ -193400,7 +193570,9 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   if (import_typescript11.default.isArrowFunction(node.arguments[0]) && children.length > 0) {
     checkLoopKey(node.arguments[0], ctx, isNested);
   }
-  const key = children.length > 0 ? extractLoopKey(children[0]) : null;
+  const itemConditional = children.length > 0 ? loopBodyItemConditional(children) : null;
+  const bodyIsItemConditional = itemConditional !== null;
+  const key = bodyIsItemConditional ? extractItemConditionalKey(itemConditional) : children.length > 0 ? extractLoopKey(children[0]) : null;
   let childComponent;
   if (children.length === 1 && children[0].type === "component") {
     const comp = children[0];
@@ -193439,6 +193611,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     callsReactiveGetters: callsReactive || undefined,
     hasFunctionCalls: hasCalls || undefined,
     bodyIsMultiRoot: bodyIsMultiRoot || undefined,
+    bodyIsItemConditional: bodyIsItemConditional || undefined,
     childComponent,
     nestedComponents,
     filterPredicate,

package/package.json

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