Add prefer-math-min-max

docs/rules/prefer-math-min-max.md

@@ -0,0 +1,56 @@
+# Prefer `Math.min()` and `Math.max()` over ternary expressions for simple comparisons
+
+💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/sindresorhus/eslint-plugin-unicorn#preset-configs-eslintconfigjs).
+
+🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+<!-- Do not manually modify this header. Run: `npm run fix:eslint-docs` -->
+
+Enforce the use of `Math.min()` and `Math.max()` instead of ternary expressions for simple comparisons. This makes the code more readable.
+
+## Examples
+
+<!-- Math.min() -->
+
+```js
+height > 50 ? 50 : height; // ❌
+Math.min(height, 50); // ✅
+```
+
+```js
+height >= 50 ? 50 : height; // ❌
+Math.min(height, 50); // ✅
+```
+
+```js
+height < 50 ? height : 50; // ❌
+Math.min(height, 50); // ✅
+```
+
+```js
+height <= 50 ? height : 50; // ❌
+Math.min(height, 50); // ✅
+```
+
+<!-- Math.max() -->
+
+```js
+height > 50 ? height : 50; // ❌
+Math.max(height, 50); // ✅
+```
+
+```js
+height >= 50 ? height : 50; // ❌
+Math.max(height, 50); // ✅
+```
+
+```js
+height < 50 ? 50 : height; // ❌
+Math.max(height, 50); // ✅
+```
+
+```js
+height <= 50 ? 50 : height; // ❌
+Math.max(height, 50); // ✅
+```

readme.md

@@ -193,6 +193,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [prefer-json-parse-buffer](docs/rules/prefer-json-parse-buffer.md)                               | Prefer reading a JSON file as a buffer.                                                                                                                                                                           |    | 🔧 |    |
 | [prefer-keyboard-event-key](docs/rules/prefer-keyboard-event-key.md)                             | Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`.                                                                                                                                                          | ✅  | 🔧 |    |
 | [prefer-logical-operator-over-ternary](docs/rules/prefer-logical-operator-over-ternary.md)       | Prefer using a logical operator over a ternary.                                                                                                                                                                   | ✅  |    | 💡 |
+| [prefer-math-min-max](docs/rules/prefer-math-min-max.md)                                         | Prefer `Math.min()` and `Math.max()` over ternary expressions for simple comparisons.                                                                                                                             | ✅  | 🔧 |    |
 | [prefer-math-trunc](docs/rules/prefer-math-trunc.md)                                             | Enforce the use of `Math.trunc` instead of bitwise operators.                                                                                                                                                     | ✅  | 🔧 | 💡 |
 | [prefer-modern-dom-apis](docs/rules/prefer-modern-dom-apis.md)                                   | Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`. | ✅  | 🔧 |    |
 | [prefer-modern-math-apis](docs/rules/prefer-modern-math-apis.md)                                 | Prefer modern `Math` APIs over legacy patterns.                                                                                                                                                                   | ✅  | 🔧 |    |

rules/prefer-math-min-max.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const MESSAGE_ID = 'prefer-math-min-max';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `{{replacement}}` to simplify ternary expressions.',
+};
+
+/**
+
+@param {import('eslint').Rule.RuleContext} context
+@param {import('estree').ConditionalExpression} node
+@param {string} method
+*/
+function reportPreferMathMinOrMax(context, node, left, right, method) {
+	const {sourceCode} = context;
+
+	context.report({
+		node,
+		messageId: MESSAGE_ID,
+		data: {
+			replacement: `${method}()`,
+			value: sourceCode.getText(node),
+		},
+		fix: fixer => fixer.replaceText(node, `${method}(${sourceCode.getText(left)}, ${sourceCode.getText(right)})`),
+	});
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	/** @param {import('estree').ConditionalExpression} node */
+	ConditionalExpression(node) {
+		const {test, consequent, alternate} = node;
+
+		if (test.type !== 'BinaryExpression') {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const {operator, left, right} = test;
+
+		const leftCode = sourceCode.getText(left);
+		const rightCode = sourceCode.getText(right);
+		const alternateCode = sourceCode.getText(alternate);
+		const consequentCode = sourceCode.getText(consequent);
+
+		switch (operator) {
+			case '>':
+			case '>=': {
+				if (leftCode === alternateCode && rightCode === consequentCode) {
+					// Example `height > 50 ? 50 : height`
+					// Prefer `Math.min()`
+					reportPreferMathMinOrMax(context, node, left, right, 'Math.min');
+				} else if (leftCode === consequentCode && rightCode === alternateCode) {
+					// Example `height > 50 ? height : 50`
+					// Prefer `Math.max()`
+					reportPreferMathMinOrMax(context, node, left, right, 'Math.max');
+				}
+
+				break;
+			}
+
+			case '<':
+			case '<=': {
+				if (leftCode === consequentCode && rightCode === alternateCode) {
+					// Example `height < 50 ? height : 50`
+					// Prefer `Math.min()`
+					reportPreferMathMinOrMax(context, node, left, right, 'Math.min');
+				} else if (leftCode === alternateCode && rightCode === consequentCode) {
+					// Example `height < 50 ? 50 : height`
+					// Prefer `Math.max()`
+					reportPreferMathMinOrMax(context, node, left, right, 'Math.max');
+				}
+
+				break;
+			}
+
+			default: {
+				break;
+			}
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Prefer `Math.min()` and `Math.max()` over ternary expressions for simple comparisons.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+	},
+};

test/package.mjs

@@ -30,6 +30,7 @@ const RULES_WITHOUT_PASS_FAIL_SECTIONS = new Set([
 	'filename-case',
 	// Intended to not use `pass`/`fail` section in this rule.
 	'prefer-modern-math-apis',
+	'prefer-math-min-max',
 ]);
 
 test('Every rule is defined in index file in alphabetical order', t => {

test/prefer-math-min-max.mjs

@@ -0,0 +1,35 @@
+import {getTester} from './utils/test.mjs';
+
+const {test} = getTester(import.meta);
+
+test.snapshot({
+	valid: [
+		'height > 10 ? height : 20',
+		'height > 50 ? Math.min(50, height) : height',
+	],
+	invalid: [
+		// Prefer `Math.min()`
+		'height > 50 ? 50 : height',
+		'height >= 50 ? 50 : height',
+		'height < 50 ? height : 50',
+		'height <= 50 ? height : 50',
+
+		// Prefer `Math.min()`
+		'height > maxHeight ? maxHeight : height',
+		'height < maxHeight ? height : maxHeight',
+
+		// Prefer `Math.min()`
+		'window.height > 50 ? 50 : window.height',
+		'window.height < 50 ? window.height : 50',
+
+		// Prefer `Math.max()`
+		'height > 50 ? height : 50',
+		'height >= 50 ? height : 50',
+		'height < 50 ? 50 : height',
+		'height <= 50 ? 50 : height',
+
+		// Prefer `Math.max()`
+		'height > maxHeight ? height : maxHeight',
+		'height < maxHeight ? maxHeight : height',
+	],
+});