@alexlit/lint-kit 174.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-structured-clone.js

@@ -0,0 +1,149 @@
+import {isCallExpression, isMethodCall} from './ast/index.js';
+import {removeParentheses} from './fix/index.js';
+import {isNodeMatchesNameOrPath, getCallExpressionTokens} from './utils/index.js';
+
+const MESSAGE_ID_ERROR = 'prefer-structured-clone/error';
+const MESSAGE_ID_SUGGESTION = 'prefer-structured-clone/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Prefer `structuredClone(…)` over `{{description}}` to create a deep clone.',
+	[MESSAGE_ID_SUGGESTION]: 'Switch to `structuredClone(…)`.',
+};
+
+const lodashCloneDeepFunctions = [
+	'_.cloneDeep',
+	'lodash.cloneDeep',
+];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {functions: configFunctions} = {
+		functions: [],
+		...context.options[0],
+	};
+	const functions = [...configFunctions, ...lodashCloneDeepFunctions];
+
+	// `JSON.parse(JSON.stringify(…))`
+	context.on('CallExpression', callExpression => {
+		if (!(
+			// `JSON.stringify()`
+			isMethodCall(callExpression, {
+				object: 'JSON',
+				method: 'parse',
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `JSON.parse()`
+			&& isMethodCall(callExpression.arguments[0], {
+				object: 'JSON',
+				method: 'stringify',
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+		)) {
+			return;
+		}
+
+		const jsonParse = callExpression;
+		const jsonStringify = callExpression.arguments[0];
+		const {sourceCode} = context;
+
+		return {
+			node: jsonParse,
+			loc: {
+				start: sourceCode.getLoc(jsonParse).start,
+				end: sourceCode.getLoc(jsonStringify.callee).end,
+			},
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				description: 'JSON.parse(JSON.stringify(…))',
+			},
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					* fix(fixer) {
+						yield fixer.replaceText(jsonParse.callee, 'structuredClone');
+
+						yield fixer.remove(jsonStringify.callee);
+						yield removeParentheses(jsonStringify.callee, fixer, context);
+
+						const {
+							openingParenthesisToken,
+							closingParenthesisToken,
+							trailingCommaToken,
+						} = getCallExpressionTokens(jsonStringify, context);
+
+						yield fixer.remove(openingParenthesisToken);
+						yield fixer.remove(closingParenthesisToken);
+						if (trailingCommaToken) {
+							yield fixer.remove(trailingCommaToken);
+						}
+					},
+				},
+			],
+		};
+	});
+
+	// `_.cloneDeep(foo)`
+	context.on('CallExpression', callExpression => {
+		if (!isCallExpression(callExpression, {
+			argumentsLength: 1,
+			optional: false,
+		})) {
+			return;
+		}
+
+		const {callee} = callExpression;
+		const matchedFunction = functions.find(nameOrPath => isNodeMatchesNameOrPath(callee, nameOrPath));
+
+		if (!matchedFunction) {
+			return;
+		}
+
+		return {
+			node: callee,
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				description: `${matchedFunction.trim()}(…)`,
+			},
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					fix: fixer => fixer.replaceText(callee, 'structuredClone'),
+				},
+			],
+		};
+	});
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			functions: {
+				type: 'array',
+				uniqueItems: true,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer using `structuredClone` to create a deep clone.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		schema,
+		defaultOptions: [{}],
+		messages,
+	},
+};
+
+export default config;

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

@@ -0,0 +1,357 @@
+import {hasSideEffect} from '@eslint-community/eslint-utils';
+import isSameReference from './utils/is-same-reference.js';
+import getIndentString from './utils/get-indent-string.js';
+
+const MESSAGE_ID = 'prefer-switch';
+const messages = {
+	[MESSAGE_ID]: 'Use `switch` instead of multiple `else-if`.',
+};
+
+const isSame = (nodeA, nodeB) => nodeA === nodeB || isSameReference(nodeA, nodeB);
+
+function getEqualityComparisons(node) {
+	const nodes = [node];
+	const compareExpressions = [];
+	while (nodes.length > 0) {
+		node = nodes.pop();
+
+		if (node.type === 'LogicalExpression' && node.operator === '||') {
+			nodes.push(node.right, node.left);
+			continue;
+		}
+
+		if (node.type !== 'BinaryExpression' || node.operator !== '===') {
+			return [];
+		}
+
+		compareExpressions.push(node);
+	}
+
+	return compareExpressions;
+}
+
+function getCommonReferences(expressions, candidates) {
+	for (const {left, right} of expressions) {
+		candidates = candidates.filter(node => isSame(node, left) || isSame(node, right));
+
+		if (candidates.length === 0) {
+			break;
+		}
+	}
+
+	return candidates;
+}
+
+function getStatements(statement) {
+	let discriminantCandidates;
+	const ifStatements = [];
+	for (; statement && statement.type === 'IfStatement'; statement = statement.alternate) {
+		const {test} = statement;
+		const compareExpressions = getEqualityComparisons(test);
+
+		if (compareExpressions.length === 0) {
+			break;
+		}
+
+		if (!discriminantCandidates) {
+			const [{left, right}] = compareExpressions;
+			discriminantCandidates = [left, right];
+		}
+
+		const candidates = getCommonReferences(
+			compareExpressions,
+			discriminantCandidates,
+		);
+
+		if (candidates.length === 0) {
+			break;
+		}
+
+		discriminantCandidates = candidates;
+
+		ifStatements.push({
+			statement,
+			compareExpressions,
+		});
+	}
+
+	return {
+		ifStatements,
+		discriminant: discriminantCandidates && discriminantCandidates[0],
+	};
+}
+
+const breakAbleNodeTypes = new Set([
+	'WhileStatement',
+	'DoWhileStatement',
+	'ForStatement',
+	'ForOfStatement',
+	'ForInStatement',
+	'SwitchStatement',
+]);
+const getBreakTarget = node => {
+	for (; node.parent; node = node.parent) {
+		if (breakAbleNodeTypes.has(node.type)) {
+			return node;
+		}
+	}
+};
+
+const isNodeInsideNode = (inner, outer, context) => {
+	const {sourceCode} = context;
+	return sourceCode.getRange(inner)[0] >= sourceCode.getRange(outer)[0] && sourceCode.getRange(inner)[1] <= sourceCode.getRange(outer)[1];
+};
+
+function hasBreakInside(breakStatements, node, context) {
+	for (const breakStatement of breakStatements) {
+		if (!isNodeInsideNode(breakStatement, node, context)) {
+			continue;
+		}
+
+		const breakTarget = getBreakTarget(breakStatement);
+
+		if (!breakTarget) {
+			return true;
+		}
+
+		if (isNodeInsideNode(node, breakTarget, context)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function * insertBracesIfNotBlockStatement(node, fixer, indent) {
+	if (!node || node.type === 'BlockStatement') {
+		return;
+	}
+
+	yield fixer.insertTextBefore(node, `{\n${indent}`);
+	yield fixer.insertTextAfter(node, `\n${indent}}`);
+}
+
+function * insertBreakStatement(node, fixer, sourceCode, indent) {
+	if (node.type === 'BlockStatement') {
+		const lastToken = sourceCode.getLastToken(node);
+		yield fixer.insertTextBefore(lastToken, `\n${indent}break;\n${indent}`);
+	} else {
+		yield fixer.insertTextAfter(node, `\n${indent}break;`);
+	}
+}
+
+function getBlockStatementLastNode(blockStatement) {
+	const {body} = blockStatement;
+	for (let index = body.length - 1; index >= 0; index--) {
+		const node = body[index];
+		if (node.type === 'FunctionDeclaration' || node.type === 'EmptyStatement') {
+			continue;
+		}
+
+		if (node.type === 'BlockStatement') {
+			const last = getBlockStatementLastNode(node);
+			if (last) {
+				return last;
+			}
+
+			continue;
+		}
+
+		return node;
+	}
+}
+
+function shouldInsertBreakStatement(node) {
+	switch (node.type) {
+		case 'ReturnStatement':
+		case 'ThrowStatement': {
+			return false;
+		}
+
+		case 'IfStatement': {
+			return !node.alternate
+				|| shouldInsertBreakStatement(node.consequent)
+				|| shouldInsertBreakStatement(node.alternate);
+		}
+
+		case 'BlockStatement': {
+			const lastNode = getBlockStatementLastNode(node);
+			return !lastNode || shouldInsertBreakStatement(lastNode);
+		}
+
+		default: {
+			return true;
+		}
+	}
+}
+
+function fix({discriminant, ifStatements}, context, options) {
+	const {sourceCode} = context;
+	const discriminantText = sourceCode.getText(discriminant);
+
+	return function * (fixer) {
+		const firstStatement = ifStatements[0].statement;
+		const indent = getIndentString(firstStatement, context);
+		yield fixer.insertTextBefore(firstStatement, `switch (${discriminantText}) {`);
+
+		const lastStatement = ifStatements.at(-1).statement;
+		if (lastStatement.alternate) {
+			const {alternate} = lastStatement;
+			yield fixer.insertTextBefore(alternate, `\n${indent}default: `);
+			/*
+			Technically, we should insert braces for the following case,
+			but who writes like this? And using `let`/`const` is invalid.
+
+			```js
+			if (foo === 1) {}
+			else if (foo === 2) {}
+			else if (foo === 3) {}
+			else var a = 1;
+			```
+			*/
+		} else {
+			switch (options.emptyDefaultCase) {
+				case 'no-default-comment': {
+					yield fixer.insertTextAfter(firstStatement, `\n${indent}// No default`);
+					break;
+				}
+
+				case 'do-nothing-comment': {
+					yield fixer.insertTextAfter(firstStatement, `\n${indent}default:\n${indent}// Do nothing`);
+					break;
+				}
+				// No default
+			}
+		}
+
+		yield fixer.insertTextAfter(firstStatement, `\n${indent}}`);
+
+		for (const {statement, compareExpressions} of ifStatements) {
+			const {consequent, alternate} = statement;
+
+			if (alternate) {
+				const [, start] = sourceCode.getRange(consequent);
+				const [end] = sourceCode.getRange(alternate);
+				yield fixer.removeRange([start, end]);
+			}
+
+			const headRange = [
+				sourceCode.getRange(statement)[0],
+				sourceCode.getRange(consequent)[0],
+			];
+			yield fixer.removeRange(headRange);
+			for (const {left, right} of compareExpressions) {
+				const node = isSame(left, discriminant) ? right : left;
+				const text = sourceCode.getText(node);
+				yield fixer.insertTextBefore(consequent, `\n${indent}case ${text}: `);
+			}
+
+			if (shouldInsertBreakStatement(consequent)) {
+				yield insertBreakStatement(consequent, fixer, sourceCode, indent);
+				yield insertBracesIfNotBlockStatement(consequent, fixer, indent);
+			}
+		}
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const options = {
+		minimumCases: 3,
+		emptyDefaultCase: 'no-default-comment',
+		insertBreakInDefaultCase: false,
+		...context.options[0],
+	};
+	const {sourceCode} = context;
+	const ifStatements = new Set();
+	const breakStatements = [];
+	const checked = new Set();
+
+	return {
+		IfStatement(node) {
+			ifStatements.add(node);
+		},
+		BreakStatement(node) {
+			if (!node.label) {
+				breakStatements.push(node);
+			}
+		},
+		* 'Program:exit'() {
+			for (const node of ifStatements) {
+				if (checked.has(node)) {
+					continue;
+				}
+
+				const {discriminant, ifStatements} = getStatements(node);
+
+				if (!discriminant || ifStatements.length < options.minimumCases) {
+					continue;
+				}
+
+				for (const {statement} of ifStatements) {
+					checked.add(statement);
+				}
+
+				const problem = {
+					loc: {
+						start: sourceCode.getLoc(node).start,
+						end: sourceCode.getLoc(node.consequent).start,
+					},
+					messageId: MESSAGE_ID,
+				};
+
+				if (
+					!hasSideEffect(discriminant, sourceCode)
+					&& !ifStatements.some(({statement}) => hasBreakInside(breakStatements, statement, context))
+				) {
+					problem.fix = fix({discriminant, ifStatements}, context, options);
+				}
+
+				yield problem;
+			}
+		},
+	};
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			minimumCases: {
+				type: 'integer',
+				minimum: 2,
+			},
+			emptyDefaultCase: {
+				enum: [
+					'no-default-comment',
+					'do-nothing-comment',
+					'no-default-case',
+				],
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `switch` over multiple `else-if`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		schema,
+		defaultOptions: [
+			{
+				minimumCases: 3,
+				emptyDefaultCase: 'no-default-comment',
+			},
+		],
+		messages,
+	},
+};
+
+export default config;