eslint-plugin-unicorn 70.0.0 → 71.1.0

package/rules/prefer-spread.js

@@ -18,6 +18,7 @@ import {
 	isTypeParameterType,
 	hasUnparenthesizedOptionalChainElement,
 	isTypeScriptExpressionWrapper,
+	isDefaultLibrarySymbol,
 } from './utils/index.js';
 import {removeMethodCall} from './fix/index.js';
 import {
@@ -155,8 +156,8 @@ function fixConcat(node, context, fixableArguments) {
 	const array = node.callee.object;
 	const concatCallArguments = node.arguments;
 	const arrayParenthesizedRange = getParenthesizedRange(array, context);
-	const arrayIsArrayLiteral = isArrayLiteral(array);
-	const arrayHasTrailingComma = arrayIsArrayLiteral && isArrayLiteralHasTrailingComma(array, sourceCode);
+	const isArrayIsArrayLiteral = isArrayLiteral(array);
+	const arrayHasTrailingComma = isArrayIsArrayLiteral && isArrayLiteralHasTrailingComma(array, sourceCode);
 
 	const getArrayLiteralElementsText = (node, keepTrailingComma) => {
 		if (
@@ -204,7 +205,7 @@ function fixConcat(node, context, fixableArguments) {
 			return '';
 		}
 
-		if (arrayIsArrayLiteral) {
+		if (isArrayIsArrayLiteral) {
 			if (!isEmptyArrayExpression(array)) {
 				text = ` ${text}`;
 
@@ -243,7 +244,7 @@ function fixConcat(node, context, fixableArguments) {
 	return function * (fixer) {
 		// Fixed code always starts with `[`
 		if (
-			!arrayIsArrayLiteral
+			!isArrayIsArrayLiteral
 			&& needsSemicolon(sourceCode.getTokenBefore(node), context, '[')
 		) {
 			yield fixer.insertTextBefore(node, ';');
@@ -257,7 +258,7 @@ function fixConcat(node, context, fixableArguments) {
 
 		const text = getFixedText();
 
-		if (arrayIsArrayLiteral) {
+		if (isArrayIsArrayLiteral) {
 			const closingBracketToken = sourceCode.getLastToken(array);
 			yield fixer.insertTextBefore(closingBracketToken, text);
 		} else {
@@ -389,9 +390,6 @@ function isGlobalMemberExpression(node, objectName, propertyName, context) {
 	return staticValue?.value === propertyName;
 }
 
-const isDefaultLibrarySymbol = (symbol, program) =>
-	symbol?.declarations?.some(declaration => program.isSourceFileDefaultLibrary(declaration.getSourceFile())) ?? false;
-
 function isBufferModuleImport(definition) {
 	return (
 		definition?.type === 'ImportBinding'
@@ -1339,11 +1337,11 @@ const create = context => {
 		};
 
 		const fixableArguments = getConcatFixableArguments(node.arguments, scope, context);
-		const receiverSafeToSpread = !isArrayConstructorWithOneArgument(object, context);
+		const isReceiverSafeToSpread = !isArrayConstructorWithOneArgument(object, context);
 
 		if (fixableArguments.length > 0 || node.arguments.length === 0) {
 			if (
-				receiverSafeToSpread
+				isReceiverSafeToSpread
 				&& !hasCommentsOutsideRanges(node, getConcatPreservedRanges(node, fixableArguments.length))
 			) {
 				problem.fix = fixConcat(node, context, fixableArguments);
@@ -1357,7 +1355,7 @@ const create = context => {
 			return problem;
 		}
 
-		if (!receiverSafeToSpread) {
+		if (!isReceiverSafeToSpread) {
 			return problem;
 		}
 
@@ -1422,17 +1420,13 @@ const create = context => {
 
 	// `array.slice()`
 	context.on('CallExpression', node => {
-		if (!(
-			isMethodCall(node, {
-				method: 'slice',
-				minimumArguments: 0,
-				maximumArguments: 1,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& !isArrayLiteral(node.callee.object)
-			&& !hasUnparenthesizedOptionalChainElement(node.callee.object, context)
-		)) {
+		if (!isMethodCall(node, {
+			method: 'slice',
+			minimumArguments: 0,
+			maximumArguments: 1,
+			optionalCall: false,
+			optionalMember: false,
+		}) || isArrayLiteral(node.callee.object) || hasUnparenthesizedOptionalChainElement(node.callee.object, context)) {
 			return;
 		}
 
@@ -1465,16 +1459,12 @@ const create = context => {
 
 	// `array.toSpliced()`
 	context.on('CallExpression', node => {
-		if (!(
-			isMethodCall(node, {
-				method: 'toSpliced',
-				argumentsLength: 0,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& node.callee.object.type !== 'ArrayExpression'
-			&& !hasUnparenthesizedOptionalChainElement(node.callee.object, context)
-		)) {
+		if (!isMethodCall(node, {
+			method: 'toSpliced',
+			argumentsLength: 0,
+			optionalCall: false,
+			optionalMember: false,
+		}) || node.callee.object.type === 'ArrayExpression' || hasUnparenthesizedOptionalChainElement(node.callee.object, context)) {
 			return;
 		}
 

package/rules/prefer-string-pad-start-end.js

@@ -1,5 +1,5 @@
 import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
-import {isMethodCall} from './ast/index.js';
+import {isMethodCall, isNumericLiteral} from './ast/index.js';
 import {
 	getParenthesizedText,
 	isSameReference,
@@ -78,11 +78,6 @@ const hasCommentsInside = (node, context) => context.sourceCode.getCommentsInsid
 
 const isSimpleTarget = node => node.type === 'Identifier';
 
-const isNumericLiteral = node => (
-	node.type === 'Literal'
-	&& typeof node.value === 'number'
-);
-
 const isZeroLiteral = node => (
 	isNumericLiteral(node)
 	&& node.value === 0

package/rules/prefer-string-repeat.js

@@ -1,4 +1,3 @@
-import jsesc from 'jsesc';
 import {isStringLiteral, isDirective} from './ast/index.js';
 import {fixSpaceAroundKeyword} from './fix/index.js';
 import isJestInlineSnapshot from './shared/is-jest-inline-snapshot.js';
@@ -10,15 +9,23 @@ const messages = {
 
 const singleWhitespace = /^\s$/u;
 
+const namedEscapes = new Map([
+	['\t', String.raw`\t`],
+	['\n', String.raw`\n`],
+	['\r', String.raw`\r`],
+	['\f', String.raw`\f`],
+]);
+
+// Escape a single whitespace character into a readable single-quoted string literal.
 function quoteWhitespace(character) {
-	return jsesc(character, {
-		quotes: 'single',
-		wrap: true,
-		es6: true,
-		minimal: false,
-		lowercaseHex: false,
-		json: true,
-	});
+	if (character === ' ') {
+		return '\' \'';
+	}
+
+	const escape = namedEscapes.get(character)
+		?? String.raw`\u{${character.codePointAt(0).toString(16).toUpperCase()}}`;
+
+	return `'${escape}'`;
 }
 
 function getRepeatedWhitespace(value, minimumRepetitions) {

package/rules/prefer-string-replace-all.js

@@ -40,7 +40,7 @@ function hasSafeGlobalStringReplacementFlags(flags) {
 	return true;
 }
 
-const getUnicodeEscape = codePoint => String.raw`\u{${codePoint.toString(16)}}`;
+const getUnicodeEscape = codePoint => String.raw`\u{${codePoint.toString(16).toUpperCase()}}`;
 
 function getValueReplacement(node) {
 	const {kind, codePoint, raw} = node;

package/rules/prefer-ternary.js

@@ -1,4 +1,5 @@
 import {hasSideEffect, findVariable} from '@eslint-community/eslint-utils';
+import {isBooleanLiteral} from './ast/index.js';
 import {
 	needsSemicolon,
 	isSameReference,
@@ -13,7 +14,6 @@ const messageId = 'prefer-ternary';
 const suggestionMessageId = 'prefer-ternary/suggestion';
 
 const isTernary = node => node?.type === 'ConditionalExpression';
-const isBooleanLiteral = node => node?.type === 'Literal' && typeof node.value === 'boolean';
 
 function getNodeBody(node) {
 	/* c8 ignore next 3 */
@@ -57,7 +57,7 @@ const isMergeableAssignmentExpression = (consequent, alternate) =>
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const onlySingleLine = context.options[0] === 'only-single-line';
+	const isOnlySingleLine = context.options[0] === 'only-single-line';
 	const {sourceCode} = context;
 
 	const getText = node => {
@@ -134,7 +134,7 @@ const create = context => {
 		}
 
 		if (
-			onlySingleLine
+			isOnlySingleLine
 			&& [node.test, right].some(n => !isSingleLineNode(n, context))
 		) {
 			return;
@@ -161,7 +161,7 @@ const create = context => {
 		}
 
 		if (
-			onlySingleLine
+			isOnlySingleLine
 			&& !isSingleLineNode(declarator.init, context)
 		) {
 			return;
@@ -245,7 +245,7 @@ const create = context => {
 		const alternate = getNodeBody(node.alternate);
 
 		if (
-			onlySingleLine
+			isOnlySingleLine
 			&& [consequent, alternate, node.test].some(node => !isSingleLineNode(node, context))
 		) {
 			return;

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);
 
 /*