@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-modern-dom-apis.js

@@ -1,145 +0,0 @@
-import {isValueNotUsable} from './utils/index.js';
-import {isMethodCall} from './ast/index.js';
-
-const messages = {
-	replaceChildOrInsertBefore:
-		'Prefer `{{oldChildNode}}.{{preferredMethod}}({{newChildNode}})` over `{{parentNode}}.{{method}}({{newChildNode}}, {{oldChildNode}})`.',
-	insertAdjacentTextOrInsertAdjacentElement:
-		'Prefer `{{reference}}.{{preferredMethod}}({{content}})` over `{{reference}}.{{method}}({{position}}, {{content}})`.',
-};
-
-const disallowedMethods = new Map([
-	['replaceChild', 'replaceWith'],
-	['insertBefore', 'before'],
-]);
-
-const checkForReplaceChildOrInsertBefore = (context, node) => {
-	const method = node.callee.property.name;
-	const parentNode = node.callee.object.name;
-	const [newChildNode, oldChildNode] = node.arguments.map(({name}) => name);
-	const preferredMethod = disallowedMethods.get(method);
-
-	const fix = isValueNotUsable(node)
-		? fixer => fixer.replaceText(
-			node,
-			`${oldChildNode}.${preferredMethod}(${newChildNode})`,
-		)
-		: undefined;
-
-	return {
-		node,
-		messageId: 'replaceChildOrInsertBefore',
-		data: {
-			parentNode,
-			method,
-			preferredMethod,
-			newChildNode,
-			oldChildNode,
-		},
-		fix,
-	};
-};
-
-const positionReplacers = new Map([
-	['beforebegin', 'before'],
-	['afterbegin', 'prepend'],
-	['beforeend', 'append'],
-	['afterend', 'after'],
-]);
-
-const checkForInsertAdjacentTextOrInsertAdjacentElement = (context, node) => {
-	const method = node.callee.property.name;
-	const [positionNode, contentNode] = node.arguments;
-
-	const position = positionNode.value;
-	// Return early when specified position value of first argument is not a recognized value.
-	if (!positionReplacers.has(position)) {
-		return;
-	}
-
-	const preferredMethod = positionReplacers.get(position);
-	const {sourceCode} = context;
-	const content = sourceCode.getText(contentNode);
-	const reference = sourceCode.getText(node.callee.object);
-
-	const fix = method === 'insertAdjacentElement' && !isValueNotUsable(node)
-		? undefined
-		// TODO: make a better fix, don't touch reference
-		: fixer => fixer.replaceText(
-			node,
-			`${reference}.${preferredMethod}(${content})`,
-		);
-
-	return {
-		node,
-		messageId: 'insertAdjacentTextOrInsertAdjacentElement',
-		data: {
-			reference,
-			method,
-			preferredMethod,
-			position: sourceCode.getText(positionNode),
-			content,
-		},
-		fix,
-	};
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('CallExpression', node => {
-		if (
-			isMethodCall(node, {
-				methods: ['replaceChild', 'insertBefore'],
-				argumentsLength: 2,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			// We only allow Identifier for now
-			&& node.arguments.every(node => node.type === 'Identifier' && node.name !== 'undefined')
-			// This check makes sure that only the first method of chained methods with same identifier name e.g: parentNode.insertBefore(alfa, beta).insertBefore(charlie, delta); gets reported
-			&& node.callee.object.type === 'Identifier'
-		) {
-			return checkForReplaceChildOrInsertBefore(context, node);
-		}
-	});
-
-	context.on('CallExpression', node => {
-		if (
-			isMethodCall(node, {
-				methods: ['insertAdjacentText', 'insertAdjacentElement'],
-				argumentsLength: 2,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			// Position argument should be `string`
-			&& node.arguments[0].type === 'Literal'
-			// TODO: remove this limits on second argument
-			&& (
-				node.arguments[1].type === 'Literal'
-				|| node.arguments[1].type === 'Identifier'
-			)
-			// TODO: remove this limits on callee
-			&& node.callee.object.type === 'Identifier'
-		) {
-			return checkForInsertAdjacentTextOrInsertAdjacentElement(context, node);
-		}
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description:
-				// eslint-disable-next-line @stylistic/max-len
-				'Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-modern-math-apis.js

@@ -1,210 +0,0 @@
-import {getParenthesizedText, getParenthesizedRange, isSameReference} from './utils/index.js';
-import {isLiteral, isMethodCall} from './ast/index.js';
-import {replaceNodeOrTokenAndSpacesBefore, removeParentheses} from './fix/index.js';
-
-const MESSAGE_ID = 'prefer-modern-math-apis';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `{{replacement}}` over `{{description}}`.',
-};
-
-const isMathProperty = (node, property) =>
-	node.type === 'MemberExpression'
-	&& !node.optional
-	&& !node.computed
-	&& node.object.type === 'Identifier'
-	&& node.object.name === 'Math'
-	&& node.property.type === 'Identifier'
-	&& node.property.name === property;
-
-const isMathMethodCall = (node, method) =>
-	node.type === 'CallExpression'
-	&& !node.optional
-	&& isMathProperty(node.callee, method)
-	&& node.arguments.length === 1
-	&& node.arguments[0].type !== 'SpreadElement';
-
-// `Math.log(x) * Math.LOG10E` -> `Math.log10(x)`
-// `Math.LOG10E * Math.log(x)` -> `Math.log10(x)`
-// `Math.log(x) * Math.LOG2E` -> `Math.log2(x)`
-// `Math.LOG2E * Math.log(x)` -> `Math.log2(x)`
-function createLogCallTimesConstantCheck({constantName, replacementMethod}) {
-	const replacement = `Math.${replacementMethod}(…)`;
-
-	return function (node, context) {
-		if (!(node.type === 'BinaryExpression' && node.operator === '*')) {
-			return;
-		}
-
-		let mathLogCall;
-		let description;
-		if (isMathMethodCall(node.left, 'log') && isMathProperty(node.right, constantName)) {
-			mathLogCall = node.left;
-			description = `Math.log(…) * Math.${constantName}`;
-		} else if (isMathMethodCall(node.right, 'log') && isMathProperty(node.left, constantName)) {
-			mathLogCall = node.right;
-			description = `Math.${constantName} * Math.log(…)`;
-		}
-
-		if (!mathLogCall) {
-			return;
-		}
-
-		const [valueNode] = mathLogCall.arguments;
-
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			data: {
-				replacement,
-				description,
-			},
-			fix: fixer => fixer.replaceText(node, `Math.${replacementMethod}(${getParenthesizedText(valueNode, context)})`),
-		};
-	};
-}
-
-// `Math.log(x) / Math.LN10` -> `Math.log10(x)`
-// `Math.log(x) / Math.LN2` -> `Math.log2(x)`
-function createLogCallDivideConstantCheck({constantName, replacementMethod}) {
-	const message = {
-		messageId: MESSAGE_ID,
-		data: {
-			replacement: `Math.${replacementMethod}(…)`,
-			description: `Math.log(…) / Math.${constantName}`,
-		},
-	};
-
-	return function (node, context) {
-		if (
-			!(
-				node.type === 'BinaryExpression'
-				&& node.operator === '/'
-				&& isMathMethodCall(node.left, 'log')
-				&& isMathProperty(node.right, constantName)
-			)
-		) {
-			return;
-		}
-
-		const [valueNode] = node.left.arguments;
-
-		return {
-			...message,
-			node,
-			fix: fixer => fixer.replaceText(node, `Math.${replacementMethod}(${getParenthesizedText(valueNode, context)})`),
-		};
-	};
-}
-
-const checkFunctions = [
-	createLogCallTimesConstantCheck({constantName: 'LOG10E', replacementMethod: 'log10'}),
-	createLogCallTimesConstantCheck({constantName: 'LOG2E', replacementMethod: 'log2'}),
-	createLogCallDivideConstantCheck({constantName: 'LN10', replacementMethod: 'log10'}),
-	createLogCallDivideConstantCheck({constantName: 'LN2', replacementMethod: 'log2'}),
-];
-
-const isPlusExpression = node => node.type === 'BinaryExpression' && node.operator === '+';
-
-const isPow2Expression = node =>
-	node.type === 'BinaryExpression'
-	&& (
-		// `x * x`
-		(node.operator === '*' && isSameReference(node.left, node.right))
-		// `x ** 2`
-		|| (node.operator === '**' && isLiteral(node.right, 2))
-	);
-
-const flatPlusExpression = node =>
-	isPlusExpression(node)
-		? [node.left, node.right].flatMap(child => flatPlusExpression(child))
-		: [node];
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const nodes = [];
-
-	return {
-		CallExpression(callExpression) {
-			if (!isMethodCall(callExpression, {
-				object: 'Math',
-				method: 'sqrt',
-				argumentsLength: 1,
-				optionalCall: false,
-				optionalMember: false,
-			})) {
-				return;
-			}
-
-			const expressions = flatPlusExpression(callExpression.arguments[0]);
-			if (expressions.some(expression => !isPow2Expression(expression))) {
-				return;
-			}
-
-			const replacementMethod = expressions.length === 1 ? 'abs' : 'hypot';
-			const plusExpressions = new Set(expressions.length === 1 ? [] : expressions.map(expression => expression.parent));
-
-			return {
-				node: callExpression.callee.property,
-				messageId: MESSAGE_ID,
-				data: {
-					replacement: `Math.${replacementMethod}(…)`,
-					description: 'Math.sqrt(…)',
-				},
-				* fix(fixer) {
-					const {sourceCode} = context;
-
-					// `Math.sqrt` -> `Math.{hypot,abs}`
-					yield fixer.replaceText(callExpression.callee.property, replacementMethod);
-
-					// `a ** 2 + b ** 2` -> `a, b`
-					for (const expression of plusExpressions) {
-						const plusToken = sourceCode.getTokenAfter(expression.left, token => token.type === 'Punctuator' && token.value === '+');
-
-						yield replaceNodeOrTokenAndSpacesBefore(plusToken, ',', fixer, context);
-						yield removeParentheses(expression, fixer, context);
-					}
-
-					// `x ** 2` => `x`
-					// `x * a` => `x`
-					for (const expression of expressions) {
-						yield fixer.removeRange([
-							getParenthesizedRange(expression.left, context)[1],
-							sourceCode.getRange(expression)[1],
-						]);
-					}
-				},
-			};
-		},
-
-		BinaryExpression(node) {
-			nodes.push(node);
-		},
-		* 'Program:exit'() {
-			for (const node of nodes) {
-				for (const getProblem of checkFunctions) {
-					const problem = getProblem(node, context);
-
-					if (problem) {
-						yield problem;
-					}
-				}
-			}
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer modern `Math` APIs over legacy patterns.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;