@alexlit/lint-kit 174.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-dom-node-dataset.js

@@ -0,0 +1,135 @@
+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 => ({
+	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/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-dom-node-remove.js

@@ -0,0 +1,124 @@
+import {isParenthesized, hasSideEffect} from '@eslint-community/eslint-utils';
+import {isMethodCall} from './ast/index.js';
+import {
+	getParenthesizedText,
+	isNodeValueNotDomNode,
+	isValueNotUsable,
+	needsSemicolon,
+	shouldAddParenthesesToMemberExpressionObject,
+} from './utils/index.js';
+
+const ERROR_MESSAGE_ID = 'error';
+const SUGGESTION_MESSAGE_ID = 'suggestion';
+const messages = {
+	[ERROR_MESSAGE_ID]: 'Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.',
+	[SUGGESTION_MESSAGE_ID]: 'Replace `parentNode.removeChild(childNode)` with `childNode{{dotOrQuestionDot}}remove()`.',
+};
+
+// TODO: Don't check node.type twice
+const isMemberExpressionOptionalObject = node =>
+	node.parent.type === 'MemberExpression'
+	&& node.parent.object === node
+	&& (
+		node.parent.optional
+		|| (node.type === 'MemberExpression' && isMemberExpressionOptionalObject(node.object))
+	);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		CallExpression(node) {
+			if (
+				!isMethodCall(node, {
+					method: 'removeChild',
+					argumentsLength: 1,
+					optionalCall: false,
+				})
+				|| isNodeValueNotDomNode(node.callee.object)
+				|| isNodeValueNotDomNode(node.arguments[0])
+			) {
+				return;
+			}
+
+			const parentNode = node.callee.object;
+			const childNode = node.arguments[0];
+
+			const problem = {
+				node,
+				messageId: ERROR_MESSAGE_ID,
+			};
+
+			const isOptionalParentNode = isMemberExpressionOptionalObject(parentNode);
+
+			const createFix = (optional = false) => fixer => {
+				let childNodeText = getParenthesizedText(childNode, context);
+				if (
+					!isParenthesized(childNode, sourceCode)
+					&& shouldAddParenthesesToMemberExpressionObject(childNode, context)
+				) {
+					childNodeText = `(${childNodeText})`;
+				}
+
+				if (needsSemicolon(sourceCode.getTokenBefore(node), context, childNodeText)) {
+					childNodeText = `;${childNodeText}`;
+				}
+
+				return fixer.replaceText(node, `${childNodeText}${optional ? '?' : ''}.remove()`);
+			};
+
+			if (!hasSideEffect(parentNode, sourceCode) && isValueNotUsable(node)) {
+				if (!isOptionalParentNode) {
+					problem.fix = createFix(false);
+					return problem;
+				}
+
+				// The most common case `foo?.parentNode.remove(foo)`
+				// TODO: Allow case like `foo.bar?.parentNode.remove(foo.bar)`
+				if (
+					node.callee.type === 'MemberExpression'
+					&& !node.callee.optional
+					&& parentNode.type === 'MemberExpression'
+					&& parentNode.optional
+					&& !parentNode.computed
+					&& parentNode.property.type === 'Identifier'
+					&& parentNode.property.name === 'parentNode'
+					&& parentNode.object.type === 'Identifier'
+					&& childNode.type === 'Identifier'
+					&& parentNode.object.name === childNode.name
+				) {
+					problem.fix = createFix(true);
+					return problem;
+				}
+			}
+
+			problem.suggest = (
+				isOptionalParentNode ? [true, false] : [false]
+			).map(optional => ({
+				messageId: SUGGESTION_MESSAGE_ID,
+				data: {dotOrQuestionDot: optional ? '?.' : '.'},
+				fix: createFix(optional),
+			}));
+
+			return problem;
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-dom-node-text-content.js

@@ -0,0 +1,77 @@
+import {isMemberExpression} from './ast/index.js';
+
+const ERROR = 'error';
+const SUGGESTION = 'suggestion';
+const messages = {
+	[ERROR]: 'Prefer `.textContent` over `.innerText`.',
+	[SUGGESTION]: 'Switch to `.textContent`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	MemberExpression(memberExpression) {
+		if (
+			!isMemberExpression(memberExpression, {
+				property: 'innerText',
+			})
+		) {
+			return;
+		}
+
+		const node = memberExpression.property;
+
+		return {
+			node,
+			messageId: ERROR,
+			suggest: [
+				{
+					messageId: SUGGESTION,
+					fix: fixer => fixer.replaceText(node, 'textContent'),
+				},
+			],
+		};
+	},
+	Identifier(node) {
+		if (!(
+			node.name === 'innerText'
+			&& node.parent.type === 'Property'
+			&& node.parent.key === node
+			&& !node.parent.computed
+			&& node.parent.kind === 'init'
+			&& node.parent.parent.type === 'ObjectPattern'
+			&& node.parent.parent.properties.includes(node.parent)
+		)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: ERROR,
+			suggest: [
+				{
+					messageId: SUGGESTION,
+					fix: fixer => fixer.replaceText(
+						node,
+						node.parent.shorthand ? 'textContent: innerText' : 'textContent',
+					),
+				},
+			],
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.textContent` over `.innerText`.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-event-target.js

@@ -0,0 +1,119 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {getAncestor} from './utils/index.js';
+import {isStaticRequire, isStringLiteral, isMemberExpression} from './ast/index.js';
+
+const MESSAGE_ID = 'prefer-event-target';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `EventTarget` over `EventEmitter`.',
+};
+
+const packagesShouldBeIgnored = new Set([
+	'@angular/core',
+	'eventemitter3',
+]);
+
+const isConstVariableDeclarationId = node =>
+	node.parent.type === 'VariableDeclarator'
+	&& node.parent.id === node
+	&& node.parent.parent.type === 'VariableDeclaration'
+	&& node.parent.parent.kind === 'const'
+	&& node.parent.parent.declarations.includes(node.parent);
+
+function isAwaitImportOrRequireFromIgnoredPackages(node) {
+	if (!node) {
+		return false;
+	}
+
+	let source;
+	if (isStaticRequire(node)) {
+		[source] = node.arguments;
+	} else if (node.type === 'AwaitExpression' && node.argument.type === 'ImportExpression') {
+		({source} = node.argument);
+	}
+
+	if (isStringLiteral(source) && packagesShouldBeIgnored.has(source.value)) {
+		return true;
+	}
+
+	return false;
+}
+
+function isFromIgnoredPackage(node) {
+	if (!node) {
+		return false;
+	}
+
+	const importDeclaration = getAncestor(node, 'ImportDeclaration');
+	if (packagesShouldBeIgnored.has(importDeclaration?.source.value)) {
+		return true;
+	}
+
+	// `const {EventEmitter} = ...`
+	if (
+		node.parent.type === 'Property'
+		&& node.parent.value === node
+		&& node.parent.key.type === 'Identifier'
+		&& node.parent.key.name === 'EventEmitter'
+		&& node.parent.parent.type === 'ObjectPattern'
+		&& node.parent.parent.properties.includes(node.parent)
+		&& isConstVariableDeclarationId(node.parent.parent)
+		&& isAwaitImportOrRequireFromIgnoredPackages(node.parent.parent.parent.init)
+	) {
+		return true;
+	}
+
+	// `const EventEmitter = (...).EventEmitter`
+	if (
+		isConstVariableDeclarationId(node)
+		&& isMemberExpression(node.parent.init, {property: 'EventEmitter', optional: false, computed: false})
+		&& isAwaitImportOrRequireFromIgnoredPackages(node.parent.init.object)
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	Identifier(node) {
+		if (!(
+			node.name === 'EventEmitter'
+			&& (
+				(
+					(node.parent.type === 'ClassDeclaration' || node.parent.type === 'ClassExpression')
+					&& node.parent.superClass === node
+				)
+				|| (node.parent.type === 'NewExpression' && node.parent.callee === node)
+			)
+		)) {
+			return;
+		}
+
+		const scope = context.sourceCode.getScope(node);
+		const variableNode = findVariable(scope, node)?.defs[0]?.name;
+		if (isFromIgnoredPackage(variableNode)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `EventTarget` over `EventEmitter`.',
+			recommended: 'unopinionated',
+		},
+		messages,
+	},
+};
+
+export default config;