eslint-plugin-unicorn 63.0.0 → 65.0.0

package/rules/better-regex.js

@@ -1,145 +0,0 @@
-import cleanRegexp from 'clean-regexp';
-import regexpTree from 'regexp-tree';
-import escapeString from './utils/escape-string.js';
-import {isStringLiteral, isNewExpression, isRegexLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'better-regex';
-const MESSAGE_ID_PARSE_ERROR = 'better-regex/parse-error';
-const messages = {
-	[MESSAGE_ID]: '{{original}} can be optimized to {{optimized}}.',
-	[MESSAGE_ID_PARSE_ERROR]: 'Problem parsing {{original}}: {{error}}',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sortCharacterClasses} = context.options[0];
-
-	const ignoreList = [];
-
-	if (sortCharacterClasses === false) {
-		ignoreList.push('charClassClassrangesMerge');
-	}
-
-	context.on('Literal', node => {
-		if (!isRegexLiteral(node)) {
-			return;
-		}
-
-		const {raw: original, regex} = node;
-		// Regular Expressions with `u` and `v` flag are not well handled by `regexp-tree`
-		// https://github.com/DmitrySoshnikov/regexp-tree/issues/162
-		if (regex.flags.includes('u') || regex.flags.includes('v')) {
-			return;
-		}
-
-		let optimized = original;
-
-		try {
-			optimized = regexpTree.optimize(original, undefined, {blacklist: ignoreList}).toString();
-		} catch (error) {
-			return {
-				node,
-				messageId: MESSAGE_ID_PARSE_ERROR,
-				data: {
-					original,
-					error: error.message,
-				},
-			};
-		}
-
-		if (original === optimized) {
-			return;
-		}
-
-		const problem = {
-			node,
-			messageId: MESSAGE_ID,
-			data: {
-				original,
-				optimized,
-			},
-		};
-
-		if (
-			node.parent.type === 'MemberExpression'
-			&& node.parent.object === node
-			&& !node.parent.optional
-			&& !node.parent.computed
-			&& node.parent.property.type === 'Identifier'
-			&& (
-				node.parent.property.name === 'toString'
-				|| node.parent.property.name === 'source'
-			)
-		) {
-			return problem;
-		}
-
-		return Object.assign(problem, {
-			fix: fixer => fixer.replaceText(node, optimized),
-		});
-	});
-
-	context.on('NewExpression', node => {
-		if (!isNewExpression(node, {name: 'RegExp', minimumArguments: 1})) {
-			return;
-		}
-
-		const [patternNode, flagsNode] = node.arguments;
-
-		if (!isStringLiteral(patternNode)) {
-			return;
-		}
-
-		const oldPattern = patternNode.value;
-		const flags = isStringLiteral(flagsNode)
-			? flagsNode.value
-			: '';
-
-		const newPattern = cleanRegexp(oldPattern, flags);
-
-		if (oldPattern !== newPattern) {
-			return {
-				node,
-				messageId: MESSAGE_ID,
-				data: {
-					original: oldPattern,
-					optimized: newPattern,
-				},
-				fix: fixer => fixer.replaceText(
-					patternNode,
-					escapeString(newPattern, patternNode.raw.charAt(0)),
-				),
-			};
-		}
-	});
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			sortCharacterClasses: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Improve regexes by making them shorter, consistent, and safer.',
-			recommended: false,
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{sortCharacterClasses: true}],
-		messages,
-	},
-};
-
-export default config;

package/rules/prefer-dom-node-dataset.js

@@ -1,135 +0,0 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
-import {escapeString, hasOptionalChainElement, isValueNotUsable} from './utils/index.js';
-import {isMethodCall, isStringLiteral, isExpressionStatement} from './ast/index.js';
-
-const {isIdentifierName} = helperValidatorIdentifier;
-const MESSAGE_ID = 'prefer-dom-node-dataset';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `.dataset` over `{{method}}(…)`.',
-};
-
-const dashToCamelCase = string => string.replaceAll(/-[a-z]/g, s => s[1].toUpperCase());
-
-function getFix(callExpression, context) {
-	const method = callExpression.callee.property.name;
-
-	// `foo?.bar = ''` is invalid
-	// TODO: Remove this restriction if https://github.com/nicolo-ribaudo/ecma262/pull/4 get merged
-	if (method === 'setAttribute' && hasOptionalChainElement(callExpression.callee)) {
-		return;
-	}
-
-	// `element.setAttribute(…)` returns `undefined`, but `AssignmentExpression` returns value of RHS
-	if (method === 'setAttribute' && !isValueNotUsable(callExpression)) {
-		return;
-	}
-
-	if (method === 'removeAttribute' && !isExpressionStatement(callExpression.parent)) {
-		return;
-	}
-
-	return fixer => {
-		const [nameNode] = callExpression.arguments;
-		const name = dashToCamelCase(nameNode.value.toLowerCase().slice(5));
-		const {sourceCode} = context;
-		let text = '';
-		const datasetText = `${sourceCode.getText(callExpression.callee.object)}${callExpression.callee.optional ? '?' : ''}.dataset`;
-		switch (method) {
-			case 'setAttribute':
-			case 'getAttribute':
-			case 'removeAttribute': {
-				text = isIdentifierName(name) ? `.${name}` : `[${escapeString(name, nameNode.raw.charAt(0))}]`;
-				text = `${datasetText}${text}`;
-				if (method === 'setAttribute') {
-					text += ` = ${sourceCode.getText(callExpression.arguments[1])}`;
-				} else if (method === 'removeAttribute') {
-					text = `delete ${text}`;
-				}
-
-				/*
-				For non-exists attribute, `element.getAttribute('data-foo')` returns `null`,
-				but `element.dataset.foo` returns `undefined`, switch to suggestions if necessary
-				*/
-				break;
-			}
-
-			case 'hasAttribute': {
-				text = `Object.hasOwn(${datasetText}, ${escapeString(name, nameNode.raw.charAt(0))})`;
-				break;
-			}
-			// No default
-		}
-
-		return fixer.replaceText(callExpression, text);
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('CallExpression', callExpression => {
-		if (!(
-			(
-				isMethodCall(callExpression, {
-					method: 'setAttribute',
-					argumentsLength: 2,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				|| isMethodCall(callExpression, {
-					methods: ['removeAttribute', 'hasAttribute'],
-					argumentsLength: 1,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				|| isMethodCall(callExpression, {
-					method: 'getAttribute',
-					argumentsLength: 1,
-					optionalCall: false,
-				})
-			)
-			&& isStringLiteral(callExpression.arguments[0])
-		)) {
-			return;
-		}
-
-		const method = callExpression.callee.property.name;
-		// Playwright's `Locator#getAttribute()` returns a promise.
-		// https://playwright.dev/docs/api/class-locator#locator-get-attribute
-		if (
-			callExpression.parent.type === 'AwaitExpression'
-			&& callExpression.parent.argument === callExpression
-			&& method === 'getAttribute'
-		) {
-			return;
-		}
-
-		const attributeName = callExpression.arguments[0].value.toLowerCase();
-
-		if (!attributeName.startsWith('data-')) {
-			return;
-		}
-
-		return {
-			node: callExpression,
-			messageId: MESSAGE_ID,
-			data: {method: callExpression.callee.property.name},
-			fix: getFix(callExpression, context),
-		};
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer using `.dataset` on DOM elements over calling attribute methods.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/rules/prefer-json-parse-buffer.js

@@ -1,161 +0,0 @@
-import {findVariable, getStaticValue, getPropertyName} from '@eslint-community/eslint-utils';
-import {isMethodCall} from './ast/index.js';
-import {removeArgument} from './fix/index.js';
-
-const MESSAGE_ID = 'prefer-json-parse-buffer';
-const messages = {
-	[MESSAGE_ID]: 'Prefer reading the JSON file as a buffer.',
-};
-
-const getAwaitExpressionArgument = node => {
-	while (node.type === 'AwaitExpression') {
-		node = node.argument;
-	}
-
-	return node;
-};
-
-function getIdentifierDeclaration(node, scope) {
-	if (!node) {
-		return;
-	}
-
-	node = getAwaitExpressionArgument(node);
-
-	if (!node || node.type !== 'Identifier') {
-		return node;
-	}
-
-	const variable = findVariable(scope, node);
-	if (!variable) {
-		return;
-	}
-
-	const {identifiers, references} = variable;
-
-	if (identifiers.length !== 1 || references.length !== 2) {
-		return;
-	}
-
-	const [identifier] = identifiers;
-
-	if (
-		identifier.parent.type !== 'VariableDeclarator'
-		|| identifier.parent.id !== identifier
-	) {
-		return;
-	}
-
-	return getIdentifierDeclaration(identifier.parent.init, variable.scope);
-}
-
-const isUtf8EncodingStringNode = (node, scope) =>
-	isUtf8EncodingString(getStaticValue(node, scope)?.value);
-
-const isUtf8EncodingString = value => {
-	if (typeof value !== 'string') {
-		return false;
-	}
-
-	value = value.toLowerCase();
-
-	// eslint-disable-next-line unicorn/text-encoding-identifier-case
-	return value === 'utf8' || value === 'utf-8';
-};
-
-function isUtf8Encoding(node, scope) {
-	if (
-		node.type === 'ObjectExpression'
-		&& node.properties.length === 1
-		&& node.properties[0].type === 'Property'
-		&& getPropertyName(node.properties[0], scope) === 'encoding'
-		&& isUtf8EncodingStringNode(node.properties[0].value, scope)
-	) {
-		return true;
-	}
-
-	if (isUtf8EncodingStringNode(node, scope)) {
-		return true;
-	}
-
-	const staticValue = getStaticValue(node, scope);
-	if (!staticValue) {
-		return false;
-	}
-
-	const {value} = staticValue;
-	if (
-		typeof value === 'object'
-		&& Object.keys(value).length === 1
-		&& isUtf8EncodingString(value.encoding)
-	) {
-		return true;
-	}
-
-	return false;
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('CallExpression', callExpression => {
-		if (!(isMethodCall(callExpression, {
-			object: 'JSON',
-			method: 'parse',
-			argumentsLength: 1,
-			optionalCall: false,
-			optionalMember: false,
-		}))) {
-			return;
-		}
-
-		let [node] = callExpression.arguments;
-		const {sourceCode} = context;
-		const scope = sourceCode.getScope(node);
-		node = getIdentifierDeclaration(node, scope);
-		if (
-			!(
-				node
-				&& node.type === 'CallExpression'
-				&& !node.optional
-				&& node.arguments.length === 2
-				&& !node.arguments.some(node => node.type === 'SpreadElement')
-				&& node.callee.type === 'MemberExpression'
-				&& !node.callee.optional
-			)
-		) {
-			return;
-		}
-
-		const method = getPropertyName(node.callee, scope);
-		if (method !== 'readFile' && method !== 'readFileSync') {
-			return;
-		}
-
-		const [, charsetNode] = node.arguments;
-		if (!isUtf8Encoding(charsetNode, scope)) {
-			return;
-		}
-
-		return {
-			node: charsetNode,
-			messageId: MESSAGE_ID,
-			fix: fixer => removeArgument(fixer, charsetNode, context),
-		};
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer reading a JSON file as a buffer.',
-			recommended: false,
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;