eslint-plugin-unicorn 70.0.0 → 71.0.0

package/rules/prefer-toggle-attribute.js

@@ -224,15 +224,15 @@ const create = context => {
 		}
 
 		const setCall = consequentCall.method === 'setAttribute' ? consequentCall : alternateCall;
-		const setWhenTrue = consequentCall === setCall;
+		const isSetWhenTrue = consequentCall === setCall;
 		const hasAttributeCondition = getHasAttributeCondition(node.test, setCall, context);
 
 		if (hasAttributeCondition?.isKnownNonDom) {
 			return;
 		}
 
-		const shouldToggleWithoutForce = Boolean(hasAttributeCondition) && setWhenTrue === hasAttributeCondition.isNegative;
-		const conditionText = shouldToggleWithoutForce ? '' : getConditionText(node.test, context, !setWhenTrue);
+		const shouldToggleWithoutForce = Boolean(hasAttributeCondition) && isSetWhenTrue === hasAttributeCondition.isNegative;
+		const conditionText = shouldToggleWithoutForce ? '' : getConditionText(node.test, context, !isSetWhenTrue);
 		const hasSafeAttributeValue = setCall.hasEmptyAttributeValue || getStaticStringValue(setCall.attributeValue) !== undefined;
 		const shouldReportOnly = (Boolean(conditionText) && setCall.isOptional) || !hasSafeAttributeValue;
 

package/rules/prefer-top-level-await.js

@@ -205,7 +205,12 @@ const isInPromiseMethods = node => {
 
 /** @param {import('eslint').Rule.RuleContext} context */
 function create(context) {
-	if (context.filename.toLowerCase().endsWith('.cjs')) {
+	// Use the real file path so processors or code blocks cannot hide file-level opt-outs.
+	const filename = context.physicalFilename.toLowerCase();
+	if (
+		filename.endsWith('.cjs')
+		|| filename.endsWith('.svelte')
+	) {
 		return;
 	}
 

package/rules/prefer-uint8array-base64.js

@@ -152,7 +152,9 @@ const config = {
 		type: 'suggestion',
 		docs: {
 			description: 'Prefer `Uint8Array#toBase64()` and `Uint8Array.fromBase64()` over `atob()`, `btoa()`, and `Buffer` base64 conversions.',
-			recommended: 'unopinionated',
+			// eslint-disable-next-line no-warning-comments
+			// TODO: Enable in the `recommended` and `unopinionated` configs when targeting Node.js 26.
+			recommended: false,
 		},
 		hasSuggestions: true,
 		messages,

package/rules/require-proxy-trap-boolean-return.js

@@ -277,8 +277,8 @@ const create = context => {
 			return;
 		}
 
-		const allUnreachable = [...currentSegments()].every(segment => !segment.reachable);
-		functionBodyAlwaysExits.set(body.parent, allUnreachable);
+		const isAllUnreachable = [...currentSegments()].every(segment => !segment.reachable);
+		functionBodyAlwaysExits.set(body.parent, isAllUnreachable);
 	});
 
 	function * checkCallOrNewExpression(node) {

package/rules/rule/to-eslint-create.js

@@ -26,7 +26,7 @@ Convert Unicorn style of `create` to ESLint style
 @param {UnicornCreate} unicornCreate
 @returns {EslintCreate}
 */
-function toEslintCreate(unicornCreate) {
+export default function toEslintCreate(unicornCreate) {
 	if (wrappedFunctions.has(unicornCreate)) {
 		return unicornCreate;
 	}
@@ -45,5 +45,4 @@ function toEslintCreate(unicornCreate) {
 	};
 }
 
-export default toEslintCreate;
 export {markFunctionWrapped};

package/rules/rule/to-eslint-listener.js

@@ -19,7 +19,7 @@ import toEslintProblem from './to-eslint-problem.js';
 @param {UnicornRuleListen} listener
 @returns {Listener}
 */
-function toEslintListener(context, listener) {
+export default function toEslintListener(context, listener) {
 	// Listener arguments can be `codePath, node` or `node`
 
 	/**
@@ -38,5 +38,3 @@ function toEslintListener(context, listener) {
 		}
 	};
 }
-
-export default toEslintListener;

package/rules/rule/to-eslint-problem.js

@@ -14,7 +14,7 @@ import toEslintFixer from './to-eslint-rule-fixer.js';
 @param {UnicornProblem} unicornProblem
 @returns {EslintProblem}
 */
-function toEslintProblem(unicornProblem) {
+export default function toEslintProblem(unicornProblem) {
 	const eslintProblem = {...unicornProblem};
 
 	if (unicornProblem.fix) {
@@ -34,5 +34,3 @@ function toEslintProblem(unicornProblem) {
 
 	return eslintProblem;
 }
-
-export default toEslintProblem;

package/rules/rule/to-eslint-rule-fixer.js

@@ -26,7 +26,7 @@ Convert Unicorn style fix function to ESLint style fix function
 @param {UnicornRuleFixer} fix
 @returns {ESLint.Rule.RuleFixer}
 */
-function toEslintRuleFixer(fix) {
+export default function toEslintRuleFixer(fix) {
 	/** @param {UnicornReportFixer} fixer */
 	return fixer => {
 		const unicornReport = fix(fixer, fixOptions);
@@ -45,5 +45,3 @@ function toEslintRuleFixer(fix) {
 		}
 	};
 }
-
-export default toEslintRuleFixer;

package/rules/rule/to-eslint-rule.js

@@ -19,7 +19,7 @@ Convert Unicorn rule to ESLint rule
 @param {UnicornRule} unicornRule
 @returns {ESLint.Rule.RuleModule}
 */
-function toEslintRule(ruleId, unicornRule) {
+export default function toEslintRule(ruleId, unicornRule) {
 	return {
 		meta: {
 			// If there is are, options add `[]` so ESLint can validate that no data is passed to the rule.
@@ -34,5 +34,3 @@ function toEslintRule(ruleId, unicornRule) {
 		create: toEslintCreate(unicornRule.create),
 	};
 }
-
-export default toEslintRule;

package/rules/rule/to-eslint-rules.js

@@ -1,11 +1,9 @@
 import toEslintRule from './to-eslint-rule.js';
 
-function toEslintRules(rules) {
+export default function toEslintRules(rules) {
 	return Object.fromEntries(Object.entries(rules).map(([ruleId, rule]) => [
 		ruleId,
 		toEslintRule(ruleId, rule),
 	]));
 }
 
-export default toEslintRules;
-

package/rules/rule/unicorn-context.js

@@ -18,7 +18,7 @@ Create a better `Context` object with `on` and `onExit` method to add listeners
 @param {UnicornListeners} listeners
 @returns {UnicornContext}
 */
-function createUnicornContext(eslintContext, listeners) {
+export default function createUnicornContext(eslintContext, listeners) {
 	/** @type {UnicornContext} */
 	const context = new Proxy(eslintContext, {
 		get(target, property, receiver) {
@@ -32,5 +32,3 @@ function createUnicornContext(eslintContext, listeners) {
 
 	return context;
 }
-
-export default createUnicornContext;

package/rules/rule/unicorn-listeners.js

@@ -4,7 +4,7 @@ import toEslintListener from './to-eslint-listener.js';
 @import {EslintListers, ListenerType, Listener} from './to-eslint-create.js'
 */
 
-class UnicornListeners {
+export default class UnicornListeners {
 	#context;
 	#listeners = new Map();
 
@@ -61,5 +61,3 @@ class UnicornListeners {
 		return eslintListeners;
 	}
 }
-
-export default UnicornListeners;

package/rules/shared/no-array-mutate-rule.js

@@ -50,7 +50,7 @@ const schema = [
 	},
 ];
 
-function noArrayMutateRule(methodName) {
+export default function noArrayMutateRule(methodName) {
 	const {
 		replacement,
 		predicate,
@@ -159,5 +159,3 @@ function noArrayMutateRule(methodName) {
 
 	return config;
 }
-
-export default noArrayMutateRule;

package/rules/shared/regexp-escape.js

@@ -19,12 +19,12 @@ const getCharacterClassCharacters = pattern => {
 
 	for (let index = 0; index < characterClass.length; index++) {
 		let character = characterClass[index];
-		let escaped = false;
+		let isEscaped = false;
 
 		if (character === '\\') {
 			index++;
 			character = characterClass[index];
-			escaped = true;
+			isEscaped = true;
 
 			if (!character) {
 				return;
@@ -33,7 +33,7 @@ const getCharacterClassCharacters = pattern => {
 
 		if (
 			character === '-'
-			&& !escaped
+			&& !isEscaped
 			&& index !== 0
 			&& index !== characterClass.length - 1
 		) {
@@ -42,7 +42,7 @@ const getCharacterClassCharacters = pattern => {
 
 		if (
 			character === ']'
-			&& !escaped
+			&& !isEscaped
 			&& index !== 0
 		) {
 			return;

package/rules/utils/can-tokens-be-adjacent.js

@@ -0,0 +1,95 @@
+/**
+@import * as ESLint from 'eslint';
+*/
+
+const WORD_CHARACTER = /[\w$]/u;
+const DECIMAL_INTEGER_LITERAL = /^\d(?:_?\d)*$/u;
+const TRAILING_DECIMAL_INTEGER_LITERAL = /(?:^|[^\w$])\d(?:_?\d)*$/u;
+const TRAILING_DIGIT_DOT = /\d\.$/u;
+
+/**
+@param {ESLint.AST.Token | string} value
+@returns {string}
+*/
+function getText(value) {
+	return typeof value === 'string' ? value : value.value;
+}
+
+/**
+@param {ESLint.AST.Token | string} value
+@returns {boolean}
+*/
+function isLineCommentOrShebang(value) {
+	return typeof value === 'object' && ['Line', 'Shebang', 'Hashbang'].includes(value.type);
+}
+
+/**
+@param {ESLint.AST.Token | string} value
+@returns {boolean}
+*/
+function isComment(value) {
+	return typeof value === 'object' && ['Line', 'Block'].includes(value.type);
+}
+
+/**
+@param {ESLint.AST.Token | string} value
+@returns {boolean}
+*/
+function isUnsafeNumericDotLeft(value) {
+	return typeof value === 'object' ? value.type === 'Numeric' && DECIMAL_INTEGER_LITERAL.test(value.value) : TRAILING_DECIMAL_INTEGER_LITERAL.test(value);
+}
+
+/**
+Checks whether `left` and `right` can be placed directly next to each other without the last character of `left` and the first character of `right` merging into a token that changes the meaning of the code (for example two identifiers becoming one, `+` and `+` becoming `++`, or `2` and `.2` becoming `2.2`).
+
+This is a lightweight, character-boundary check, not a full tokenizer, inspired by ESLint's own (more thorough) `canTokensBeAdjacent`: https://github.com/eslint/eslint/blob/b23015955c8d6e6516076190730f538c86927f26/lib/rules/utils/ast-utils.js#L2522-L2529
+It only guards against the adjacency hazards that come up when building fixer replacement text in this codebase: identifiers/keywords/numbers merging, `+`/`-` doubling into `++`/`--`, a numeric literal absorbing a following decimal point, and a `/` being swallowed into a following comment. It intentionally doesn't try to detect hazards that require a real tokenizer, like an already-open `//` comment inside `left`, or malformed token text.
+
+@param {ESLint.AST.Token | string} left - The left token or text.
+@param {ESLint.AST.Token | string} right - The right token or text.
+@returns {boolean} `false` if a space is needed between `left` and `right` to keep them from merging. `true` if they can safely be adjacent.
+*/
+export default function canTokensBeAdjacent(left, right) {
+	if (isLineCommentOrShebang(left)) {
+		return false;
+	}
+
+	const leftText = getText(left);
+
+	if (leftText === '') {
+		return true;
+	}
+
+	const rightText = getText(right);
+	const lastCharacter = leftText.at(-1);
+
+	if (lastCharacter === '/' && isComment(right)) {
+		return false;
+	}
+
+	if (rightText === '') {
+		return true;
+	}
+
+	const firstCharacter = rightText[0];
+
+	if (WORD_CHARACTER.test(lastCharacter) && WORD_CHARACTER.test(firstCharacter)) {
+		return false;
+	}
+
+	if (
+		(lastCharacter === '+' && firstCharacter === '+')
+		|| (lastCharacter === '-' && firstCharacter === '-')
+	) {
+		return false;
+	}
+
+	if (
+		(isUnsafeNumericDotLeft(left) && firstCharacter === '.')
+		|| (TRAILING_DIGIT_DOT.test(leftText) && WORD_CHARACTER.test(firstCharacter))
+	) {
+		return false;
+	}
+
+	return !(lastCharacter === '/' && (firstCharacter === '/' || firstCharacter === '*'));
+}

package/rules/utils/escape-string.js

@@ -1,4 +1,4 @@
-import jsesc from 'jsesc';
+import quoteJsString from 'quote-js-string';
 
 /**
 Escape string and wrap the result in quotes.
@@ -14,11 +14,5 @@ export default function escapeString(string, quote = '\'') {
 	}
 	/* c8 ignore end */
 
-	return jsesc(string, {
-		quotes: quote === '"' ? 'double' : 'single',
-		wrap: true,
-		es6: true,
-		minimal: true,
-		lowercaseHex: false,
-	});
+	return quoteJsString(string, quote);
 }

package/rules/utils/get-available-variable-name.js

@@ -1,13 +1,7 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
+import isIdentifier from 'is-identifier';
 import resolveVariableName from './resolve-variable-name.js';
 import getReferences from './get-references.js';
 
-const {
-	isIdentifierName,
-	isStrictReservedWord,
-	isKeyword,
-} = helperValidatorIdentifier;
-
 // https://github.com/microsoft/TypeScript/issues/2536#issuecomment-87194347
 const typescriptReservedWords = new Set([
 	'break',
@@ -72,14 +66,9 @@ const typescriptReservedWords = new Set([
 	'of',
 ]);
 
-// Copied from https://github.com/babel/babel/blob/fce35af69101c6b316557e28abf60bdbf77d6a36/packages/babel-types/src/validators/isValidIdentifier.ts#L7
-// Use this function instead of `require('@babel/types').isIdentifier`, since `@babel/helper-validator-identifier` package is much smaller
 const isValidIdentifier = name =>
 	typeof name === 'string'
-	&& !isKeyword(name)
-	&& !isStrictReservedWord(name, true)
-	&& isIdentifierName(name)
-	&& name !== 'arguments'
+	&& isIdentifier(name)
 	&& !typescriptReservedWords.has(name);
 
 /*

package/rules/utils/get-precedence.js

@@ -0,0 +1,112 @@
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+*/
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
+// Copied from https://github.com/eslint/eslint/blob/b23015955c8d6e6516076190730f538c86927f26/lib/rules/utils/ast-utils.js#L1879-L1971
+// and extended with TypeScript node types, following https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/getOperatorPrecedence.ts
+
+const logicalOperatorPrecedence = {
+	'??': 4,
+	'||': 4,
+	'&&': 5,
+};
+
+const binaryOperatorPrecedence = {
+	'|': 6,
+	'^': 7,
+	'&': 8,
+	'==': 9,
+	'!=': 9,
+	'===': 9,
+	'!==': 9,
+	'<': 10,
+	'<=': 10,
+	'>': 10,
+	'>=': 10,
+	in: 10,
+	instanceof: 10,
+	'<<': 11,
+	'>>': 11,
+	'>>>': 11,
+	'+': 12,
+	'-': 12,
+	'*': 13,
+	'/': 13,
+	'%': 13,
+	'**': 15,
+};
+
+// Precedence boundaries the `should-add-parentheses-to-*` helpers compare against. Exported so those
+// callers can name the boundary instead of hardcoding a bare number that only makes sense against the
+// table below.
+// `UnaryExpression`, `AwaitExpression`, `TSTypeAssertion`, `TSNonNullExpression`, prefix `UpdateExpression`.
+export const PRECEDENCE_UNARY = 16;
+// `CallExpression`, `ChainExpression`, `ImportExpression`.
+export const PRECEDENCE_CALL = 18;
+
+/**
+Get the operator precedence level of a given node. A higher number binds tighter.
+
+This only covers node types that can appear as an operand of another expression (the kind of nodes these `should-add-parentheses-to-*` helpers compare against a surrounding operator); node types that can't (statements, patterns, etc) are not meaningful to compare and are not included.
+
+This is only safe to use for a "is this operand's precedence lower than the precedence required by its new position" check (`getPrecedence(node) < requiredPrecedence`). It's not enough on its own to decide whether an operand needs parentheses *within a `BinaryExpression`/`LogicalExpression` of the same precedence class it already belongs to* - that also depends on associativity (`**` is right-associative, so `(a ** b) ** c` needs parentheses around the left operand even though both sides have the same precedence) and, for `LogicalExpression`, on whether `??` and `&&`/`||` are being mixed (a `SyntaxError` regardless of precedence, see `isMixedLogicalAndCoalesceExpressions` in ESLint's own `ast-utils.js`).
+
+@param {ESTree.Node} node - The AST node to check.
+@returns {number} The precedence level. Node types this function doesn't recognize (for example `Identifier`, `Literal`, or `MemberExpression`) get the highest level, since they never need to be parenthesized based on precedence alone.
+*/
+export default function getPrecedence(node) {
+	switch (node.type) {
+		case 'SequenceExpression': {
+			return 0;
+		}
+
+		case 'AssignmentExpression':
+		case 'ArrowFunctionExpression':
+		case 'YieldExpression': {
+			return 1;
+		}
+
+		case 'ConditionalExpression': {
+			return 3;
+		}
+
+		case 'LogicalExpression': {
+			return logicalOperatorPrecedence[node.operator];
+		}
+
+		case 'BinaryExpression': {
+			return binaryOperatorPrecedence[node.operator];
+		}
+
+		case 'TSAsExpression':
+		case 'TSSatisfiesExpression': {
+			return 10;
+		}
+
+		case 'UnaryExpression':
+		case 'AwaitExpression':
+		case 'TSTypeAssertion':
+		case 'TSNonNullExpression': {
+			return PRECEDENCE_UNARY;
+		}
+
+		case 'UpdateExpression': {
+			return node.prefix ? PRECEDENCE_UNARY : 17;
+		}
+
+		case 'CallExpression':
+		case 'ChainExpression':
+		case 'ImportExpression': {
+			return PRECEDENCE_CALL;
+		}
+
+		case 'NewExpression': {
+			return 19;
+		}
+
+		default: {
+			return 20;
+		}
+	}
+}

package/rules/utils/get-token-store.js

@@ -6,7 +6,7 @@
 @param {import('estree').Node} node
 @returns {import('eslint').SourceCode}
 */
-function getTokenStore(context, node) {
+export default function getTokenStore(context, node) {
 	const {sourceCode} = context;
 
 	if (
@@ -20,5 +20,3 @@ function getTokenStore(context, node) {
 
 	return sourceCode;
 }
-
-export default getTokenStore;

package/rules/utils/global-reference-tracker.js

@@ -25,6 +25,9 @@ const mergeTraceMap = (target, source) => {
 };
 
 export class GlobalReferenceTracker {
+	static READ = ReferenceTracker.READ;
+	static CALL = ReferenceTracker.CALL;
+	static CONSTRUCT = ReferenceTracker.CONSTRUCT;
 	#traceMap = {};
 	#context;
 	#filter;
@@ -73,9 +76,3 @@ export class GlobalReferenceTracker {
 		);
 	}
 }
-
-Object.assign(GlobalReferenceTracker, {
-	READ: ReferenceTracker.READ,
-	CALL: ReferenceTracker.CALL,
-	CONSTRUCT: ReferenceTracker.CONSTRUCT,
-});

package/rules/utils/index.js

@@ -23,6 +23,7 @@ export {
 } from './boolean.js';
 
 export {default as assertToken} from './assert-token.js';
+export {default as canTokensBeAdjacent} from './can-tokens-be-adjacent.js';
 export {default as cartesianProductSamples} from './cartesian-product-samples.js';
 export {default as containsSuspensionPoint} from './contains-suspension-point.js';
 export {default as escapeString} from './escape-string.js';
@@ -32,6 +33,7 @@ export {default as getCallExpressionArgumentsText} from './get-call-expression-a
 export {getCallExpressionTokens, getNewExpressionTokens} from './get-call-or-new-expression-tokens.js';
 export {default as getDuplicateArrayElements, isComparableStaticValue} from './get-duplicate-array-elements.js';
 export {default as getIndentString} from './get-indent-string.js';
+export {default as isIdentifierName} from './is-identifier-name.js';
 export {default as getComments} from './get-comments.js';
 export {
 	getLastTrailingCommentOnSameLine,
@@ -94,6 +96,7 @@ export {default as isNodeValueNotFunction} from './is-node-value-not-function.js
 export {default as isNodeContainsLexicalThis} from './is-node-contains-lexical-this.js';
 export {default as isOnSameLine} from './is-on-same-line.js';
 export {default as isPromiseType} from './is-promise-type.js';
+export {default as isReactHookName} from './is-react-hook-name.js';
 export {default as isSameIdentifier} from './is-same-identifier.js';
 export {default as isSameReference} from './is-same-reference.js';
 export {default as isUnresolvedVariable} from './is-unresolved-variable.js';
@@ -133,6 +136,7 @@ export {
 	isBuiltinSet,
 } from './builtin-collection-type.js';
 export {checkVueTemplate} from './rule.js';
+export {default as getPrecedence} from './get-precedence.js';
 export {default as shouldAddParenthesesToAwaitExpressionArgument} from './should-add-parentheses-to-await-expression-argument.js';
 export {default as shouldAddParenthesesToCallExpressionCallee} from './should-add-parentheses-to-call-expression-callee.js';
 export {default as shouldAddParenthesesToConditionalExpressionChild} from './should-add-parentheses-to-conditional-expression-child.js';