@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/better-regex.js

@@ -1,146 +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');
-	}
-
-	return {
-		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),
-			});
-		},
-		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/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/catch-error-name.js

@@ -1,138 +0,0 @@
-import {isRegExp} from 'node:util/types';
-import {findVariable} from '@eslint-community/eslint-utils';
-import {getAvailableVariableName, upperFirst} from './utils/index.js';
-import {renameVariable} from './fix/index.js';
-import {isMethodCall} from './ast/index.js';
-
-const MESSAGE_ID = 'catch-error-name';
-const messages = {
-	[MESSAGE_ID]: 'The catch parameter `{{originalName}}` should be named `{{fixedName}}`.',
-};
-
-// - `promise.then(…, foo => {})`
-// - `promise.then(…, function(foo) {})`
-// - `promise.catch(foo => {})`
-// - `promise.catch(function(foo) {})`
-const isPromiseCatchParameter = node =>
-	(node.parent.type === 'FunctionExpression' || node.parent.type === 'ArrowFunctionExpression')
-	&& node.parent.params[0] === node
-	&& (
-		isMethodCall(node.parent.parent, {
-			method: 'then',
-			argumentsLength: 2,
-			optionalCall: false,
-		})
-		|| isMethodCall(node.parent.parent, {
-			method: 'catch',
-			argumentsLength: 1,
-			optionalCall: false,
-		})
-	)
-	&& node.parent.parent.arguments.at(-1) === node.parent;
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const options = {
-		name: 'error',
-		ignore: [],
-		...context.options[0],
-	};
-	const {name: expectedName} = options;
-	const ignore = options.ignore.map(
-		pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u'),
-	);
-	const isNameAllowed = name =>
-		name === expectedName
-		|| ignore.some(regexp => regexp.test(name))
-		|| name.endsWith(expectedName)
-		|| name.endsWith(upperFirst(expectedName));
-
-	return {
-		Identifier(node) {
-			if (
-				!(node.parent.type === 'CatchClause' && node.parent.param === node)
-				&& !isPromiseCatchParameter(node)
-			) {
-				return;
-			}
-
-			const originalName = node.name;
-
-			if (
-				isNameAllowed(originalName)
-				|| isNameAllowed(originalName.replaceAll(/_+$/g, ''))
-			) {
-				return;
-			}
-
-			const scope = context.sourceCode.getScope(node);
-			const variable = findVariable(scope, node);
-
-			// This was reported https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1075#issuecomment-768072967
-			// But can't reproduce, just ignore this case
-			/* c8 ignore next 3 */
-			if (!variable) {
-				return;
-			}
-
-			if (originalName === '_' && variable.references.length === 0) {
-				return;
-			}
-
-			const scopes = [
-				variable.scope,
-				...variable.references.map(({from}) => from),
-			];
-			const fixedName = getAvailableVariableName(expectedName, scopes);
-
-			const problem = {
-				node,
-				messageId: MESSAGE_ID,
-				data: {
-					originalName,
-					fixedName: fixedName || expectedName,
-				},
-			};
-
-			if (fixedName) {
-				problem.fix = fixer => renameVariable(variable, fixedName, context, fixer);
-			}
-
-			return problem;
-		},
-	};
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			name: {
-				type: 'string',
-			},
-			ignore: {
-				type: 'array',
-				uniqueItems: true,
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce a specific parameter name in catch clauses.',
-			recommended: true,
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/consistent-assert.js

@@ -1,98 +0,0 @@
-const MESSAGE_ID_ERROR = 'consistent-assert/error';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Prefer `{{name}}.ok(…)` over `{{name}}(…)`.',
-};
-
-/**
-@param {import('estree').ImportSpecifier | import('estree').ImportDefaultSpecifier | import('estree').ImportSpecifier | import('estree').ImportDeclaration} node
-*/
-const isValueImport = node => !node.importKind || node.importKind === 'value';
-
-/**
-Check if a specifier is `assert` function.
-
-@param {import('estree').ImportSpecifier | import('estree').ImportDefaultSpecifier} specifier
-@param {string} moduleName
-*/
-const isAssertFunction = (specifier, moduleName) =>
-	// `import assert from 'node:assert';`
-	// `import assert from 'node:assert/strict';`
-	specifier.type === 'ImportDefaultSpecifier'
-	// `import {default as assert} from 'node:assert';`
-	// `import {default as assert} from 'node:assert/strict';`
-	|| (
-		specifier.type === 'ImportSpecifier'
-		&& specifier.imported.name === 'default'
-	)
-	// `import {strict as assert} from 'node:assert';`
-	|| (
-		moduleName === 'assert'
-		&& specifier.type === 'ImportSpecifier'
-		&& specifier.imported.name === 'strict'
-	);
-
-const NODE_PROTOCOL = 'node:';
-
-/** @type {import('eslint').Rule.RuleModule['create']} */
-const create = context => ({
-	* ImportDeclaration(importDeclaration) {
-		if (!isValueImport(importDeclaration)) {
-			return;
-		}
-
-		let moduleName = importDeclaration.source.value;
-
-		if (moduleName.startsWith(NODE_PROTOCOL)) {
-			moduleName = moduleName.slice(NODE_PROTOCOL.length);
-		}
-
-		if (moduleName !== 'assert' && moduleName !== 'assert/strict') {
-			return;
-		}
-
-		for (const specifier of importDeclaration.specifiers) {
-			if (!isValueImport(specifier) || !isAssertFunction(specifier, moduleName)) {
-				continue;
-			}
-
-			const variables = context.sourceCode.getDeclaredVariables(specifier);
-
-			/* c8 ignore next 3 */
-			if (!Array.isArray(variables) && variables.length === 1) {
-				continue;
-			}
-
-			const [variable] = variables;
-
-			for (const {identifier} of variable.references) {
-				if (!(identifier.parent.type === 'CallExpression' && identifier.parent.callee === identifier)) {
-					continue;
-				}
-
-				yield {
-					node: identifier,
-					messageId: MESSAGE_ID_ERROR,
-					data: {name: identifier.name},
-					/** @param {import('eslint').Rule.RuleFixer} fixer */
-					fix: fixer => fixer.insertTextAfter(identifier, '.ok'),
-				};
-			}
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Enforce consistent assertion style with `node:assert`.',
-			recommended: true,
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/consistent-date-clone.js

@@ -1,54 +0,0 @@
-import {isMethodCall, isNewExpression} from './ast/index.js';
-import {removeMethodCall} from './fix/index.js';
-
-const MESSAGE_ID_ERROR = 'consistent-date-clone/error';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Unnecessary `.getTime()` call.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	NewExpression(newExpression) {
-		if (!isNewExpression(newExpression, {name: 'Date', argumentsLength: 1})) {
-			return;
-		}
-
-		const [callExpression] = newExpression.arguments;
-
-		if (!isMethodCall(callExpression, {
-			method: 'getTime',
-			argumentsLength: 0,
-			optionalCall: false,
-			optionalMember: false,
-		})) {
-			return;
-		}
-
-		const {sourceCode} = context;
-		return {
-			node: callExpression,
-			loc: {
-				start: sourceCode.getLoc(callExpression.callee.property).start,
-				end: sourceCode.getLoc(callExpression).end,
-			},
-			messageId: MESSAGE_ID_ERROR,
-			fix: fixer => removeMethodCall(fixer, callExpression, context),
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer passing `Date` directly to the constructor when cloning.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/consistent-destructuring.js

@@ -1,168 +0,0 @@
-import {getAvailableVariableName, isLeftHandSide} from './utils/index.js';
-import {isCallOrNewExpression} from './ast/index.js';
-
-const MESSAGE_ID = 'consistentDestructuring';
-const MESSAGE_ID_SUGGEST = 'consistentDestructuringSuggest';
-
-const isSimpleExpression = expression => {
-	while (expression) {
-		if (expression.computed) {
-			return false;
-		}
-
-		if (expression.type !== 'MemberExpression') {
-			break;
-		}
-
-		expression = expression.object;
-	}
-
-	return expression.type === 'Identifier'
-		|| expression.type === 'ThisExpression';
-};
-
-const isChildInParentScope = (child, parent) => {
-	while (child) {
-		if (child === parent) {
-			return true;
-		}
-
-		child = child.upper;
-	}
-
-	return false;
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-	const declarations = new Map();
-
-	return {
-		VariableDeclarator(node) {
-			if (!(
-				node.id.type === 'ObjectPattern'
-				&& node.init
-				&& node.init.type !== 'Literal'
-				// Ignore any complex expressions (e.g. arrays, functions)
-				&& isSimpleExpression(node.init)
-			)) {
-				return;
-			}
-
-			declarations.set(sourceCode.getText(node.init), {
-				scope: sourceCode.getScope(node),
-				variables: sourceCode.getDeclaredVariables(node),
-				objectPattern: node.id,
-			});
-		},
-		MemberExpression(node) {
-			if (
-				node.computed
-				|| (
-					isCallOrNewExpression(node.parent)
-					&& node.parent.callee === node
-				)
-				|| isLeftHandSide(node)
-			) {
-				return;
-			}
-
-			const declaration = declarations.get(sourceCode.getText(node.object));
-
-			if (!declaration) {
-				return;
-			}
-
-			const {scope, objectPattern} = declaration;
-			const memberScope = sourceCode.getScope(node);
-
-			// Property is destructured outside the current scope
-			if (!isChildInParentScope(memberScope, scope)) {
-				return;
-			}
-
-			const destructurings = objectPattern.properties.filter(property =>
-				property.type === 'Property'
-				&& property.key.type === 'Identifier'
-				&& property.value.type === 'Identifier',
-			);
-			const lastProperty = objectPattern.properties.at(-1);
-
-			const hasRest = lastProperty && lastProperty.type === 'RestElement';
-
-			const expression = sourceCode.getText(node);
-			const member = sourceCode.getText(node.property);
-
-			// Member might already be destructured
-			const destructuredMember = destructurings.find(property =>
-				property.key.name === member,
-			);
-
-			if (!destructuredMember) {
-				// Don't destructure additional members when rest is used
-				if (hasRest) {
-					return;
-				}
-
-				// Destructured member collides with an existing identifier
-				if (getAvailableVariableName(member, [memberScope]) !== member) {
-					return;
-				}
-			}
-
-			// Don't try to fix nested member expressions
-			if (node.parent.type === 'MemberExpression') {
-				return {
-					node,
-					messageId: MESSAGE_ID,
-				};
-			}
-
-			const newMember = destructuredMember ? destructuredMember.value.name : member;
-
-			return {
-				node,
-				messageId: MESSAGE_ID,
-				suggest: [{
-					messageId: MESSAGE_ID_SUGGEST,
-					data: {
-						expression,
-						property: newMember,
-					},
-					* fix(fixer) {
-						const {properties} = objectPattern;
-						const lastProperty = properties.at(-1);
-
-						yield fixer.replaceText(node, newMember);
-
-						if (!destructuredMember) {
-							yield lastProperty
-								? fixer.insertTextAfter(lastProperty, `, ${newMember}`)
-								: fixer.replaceText(objectPattern, `{${newMember}}`);
-						}
-					},
-				}],
-			};
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Use destructured variables over properties.',
-			recommended: false,
-		},
-		hasSuggestions: true,
-		messages: {
-			[MESSAGE_ID]: 'Use destructured variables over properties.',
-			[MESSAGE_ID_SUGGEST]: 'Replace `{{expression}}` with destructured property `{{property}}`.',
-		},
-	},
-};
-
-export default config;