@barefootjs/test 0.4.0 → 0.5.0

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)) {

package/package.json

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