@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-import-meta-properties.js

@@ -1,320 +0,0 @@
-import {findVariable} from '@eslint-community/eslint-utils';
-import {
-	isMemberExpression,
-	isCallExpression,
-	isNewExpression,
-	isMethodCall,
-} from './ast/index.js';
-
-const ERROR_DIRNAME = 'error/calculate-dirname';
-const ERROR_FILENAME = 'error/calculate-filename';
-const messages = {
-	[ERROR_DIRNAME]: 'Do not construct dirname.',
-	[ERROR_FILENAME]: 'Do not construct filename using `fileURLToPath()`.',
-};
-
-const isParentLiteral = node => {
-	if (node?.type !== 'Literal') {
-		return false;
-	}
-
-	return node.value === '.' || node.value === './';
-};
-
-const isImportMeta = node =>
-	node.type === 'MetaProperty'
-	&& node.meta.name === 'import'
-	&& node.property.name === 'meta';
-
-function isNodeBuiltinModuleFunctionCall(node, {modules, functionName, sourceCode}) {
-	if (!isCallExpression(node, {optional: false, argumentsLength: 1})) {
-		return false;
-	}
-
-	const visited = new Set();
-
-	return checkExpression(node.callee, 'property');
-
-	/** @param {import('estree').Expression} node */
-	function checkExpression(node, checkKind) {
-		if (node.type === 'MemberExpression') {
-			if (!(
-				checkKind === 'property'
-				&& isMemberExpression(node, {property: functionName, computed: false, optional: false})
-			)) {
-				return false;
-			}
-
-			return checkExpression(node.object, 'module');
-		}
-
-		if (node.type === 'CallExpression') {
-			if (checkKind !== 'module') {
-				return false;
-			}
-
-			// `process.getBuiltinModule('x')`
-			return (
-				isMethodCall(node, {
-					object: 'process',
-					method: 'getBuiltinModule',
-					argumentsLength: 1,
-					optionalMember: false,
-					optionalCall: false,
-				})
-				&& isModuleLiteral(node.arguments[0])
-			);
-		}
-
-		if (node.type !== 'Identifier') {
-			return false;
-		}
-
-		if (visited.has(node)) {
-			return false;
-		}
-
-		visited.add(node);
-
-		const variable = findVariable(sourceCode.getScope(node), node);
-		if (!variable || variable.defs.length !== 1) {
-			return;
-		}
-
-		return checkDefinition(variable.defs[0], checkKind);
-	}
-
-	/** @param {import('eslint').Scope.Definition} define */
-	function checkDefinition(define, checkKind) {
-		if (define.type === 'ImportBinding') {
-			if (!isModuleLiteral(define.parent.source)) {
-				return false;
-			}
-
-			const specifier = define.node;
-			return checkKind === 'module'
-				? (specifier?.type === 'ImportDefaultSpecifier' || specifier?.type === 'ImportNamespaceSpecifier')
-				: (specifier?.type === 'ImportSpecifier' && specifier.imported.name === functionName);
-		}
-
-		return define.type === 'Variable' && checkPattern(define.name, checkKind);
-	}
-
-	/** @param {import('estree').Identifier | import('estree').ObjectPattern} node */
-	function checkPattern(node, checkKind) {
-		/** @type {{parent?: import('estree').Node}} */
-		const {parent} = node;
-		if (parent.type === 'VariableDeclarator') {
-			if (
-				!parent.init
-				|| parent.id !== node
-				|| parent.parent.type !== 'VariableDeclaration'
-				|| parent.parent.kind !== 'const'
-			) {
-				return false;
-			}
-
-			return checkExpression(parent.init, checkKind);
-		}
-
-		if (parent.type === 'Property') {
-			if (!(
-				checkKind === 'property'
-				&& parent.value === node
-				&& !parent.computed
-				&& parent.key.type === 'Identifier'
-				&& parent.key.name === functionName
-			)) {
-				return false;
-			}
-
-			// Check for ObjectPattern
-			return checkPattern(parent.parent, 'module');
-		}
-
-		return false;
-	}
-
-	function isModuleLiteral(node) {
-		return node?.type === 'Literal' && modules.has(node.value);
-	}
-}
-
-/**
-@returns {node is import('estree').SimpleCallExpression}
-*/
-function isUrlFileURLToPathCall(node, sourceCode) {
-	return isNodeBuiltinModuleFunctionCall(node, {
-		modules: new Set(['url', 'node:url']),
-		functionName: 'fileURLToPath',
-		sourceCode,
-	});
-}
-
-/**
-@returns {node is import('estree').SimpleCallExpression}
-*/
-function isPathDirnameCall(node, sourceCode) {
-	return isNodeBuiltinModuleFunctionCall(node, {
-		modules: new Set(['path', 'node:path']),
-		functionName: 'dirname',
-		sourceCode,
-	});
-}
-
-function create(context) {
-	const {sourceCode} = context;
-
-	context.on('MetaProperty', function * (node) {
-		if (!isImportMeta(node)) {
-			return;
-		}
-
-		/** @type {import('estree').Node} */
-		const memberExpression = node.parent;
-		if (!isMemberExpression(memberExpression, {
-			properties: ['url', 'filename'],
-			computed: false,
-			optional: false,
-		})) {
-			return;
-		}
-
-		const propertyName = memberExpression.property.name;
-		if (propertyName === 'url') {
-			// `url.fileURLToPath(import.meta.url)`
-			if (
-				isUrlFileURLToPathCall(memberExpression.parent, sourceCode)
-				&& memberExpression.parent.arguments[0] === memberExpression
-			) {
-				yield iterateProblemsFromFilename(memberExpression.parent, {
-					reportFilenameNode: true,
-				});
-				return;
-			}
-
-			// `new URL(import.meta.url)`
-			// `new URL('.', import.meta.url)`
-			// `new URL('./', import.meta.url)`
-			if (isNewExpression(memberExpression.parent, {name: 'URL', minimumArguments: 1, maximumArguments: 2})) {
-				const newUrl = memberExpression.parent;
-				const urlParent = newUrl.parent;
-
-				// `new URL(import.meta.url)`
-				if (
-					newUrl.arguments.length === 1
-					&& newUrl.arguments[0] === memberExpression
-					// `url.fileURLToPath(new URL(import.meta.url))`
-					&& isUrlFileURLToPathCall(urlParent, sourceCode)
-					&& urlParent.arguments[0] === newUrl
-				) {
-					yield iterateProblemsFromFilename(urlParent, {
-						reportFilenameNode: true,
-					});
-					return;
-				}
-
-				// `url.fileURLToPath(new URL(".", import.meta.url))`
-				// `url.fileURLToPath(new URL("./", import.meta.url))`
-				if (
-					newUrl.arguments.length === 2
-					&& isParentLiteral(newUrl.arguments[0])
-					&& newUrl.arguments[1] === memberExpression
-					&& isUrlFileURLToPathCall(urlParent, sourceCode)
-					&& urlParent.arguments[0] === newUrl
-				) {
-					yield getProblem(urlParent, 'dirname');
-				}
-			}
-
-			return;
-		}
-
-		if (propertyName === 'filename') {
-			yield iterateProblemsFromFilename(memberExpression);
-		}
-
-		/**
-		Iterates over reports where a given filename expression node
-		would be used to convert it to a dirname.
-		@param { import('estree').Expression} node
-		*/
-		function * iterateProblemsFromFilename(node, {reportFilenameNode = false} = {}) {
-			/** @type {{parent: import('estree').Node}} */
-			const {parent} = node;
-
-			// `path.dirname(filename)`
-			if (
-				isPathDirnameCall(parent, sourceCode)
-				&& parent.arguments[0] === node
-			) {
-				yield getProblem(parent, 'dirname');
-				return;
-			}
-
-			if (reportFilenameNode) {
-				yield getProblem(node, 'filename');
-			}
-
-			if (
-				parent.type !== 'VariableDeclarator'
-				|| parent.init !== node
-				|| parent.id.type !== 'Identifier'
-				|| parent.parent.type !== 'VariableDeclaration'
-				|| parent.parent.kind !== 'const'
-			) {
-				return;
-			}
-
-			/** @type {import('eslint').Scope.Variable|null} */
-			const variable = findVariable(sourceCode.getScope(parent.id), parent.id);
-			if (!variable) {
-				return;
-			}
-
-			for (const reference of variable.references) {
-				if (!reference.isReadOnly()) {
-					continue;
-				}
-
-				/** @type {{parent: import('estree').Node}} */
-				const {parent} = reference.identifier;
-				if (
-					isPathDirnameCall(parent, sourceCode)
-					&& parent.arguments[0] === reference.identifier
-				) {
-					// Report `path.dirname(identifier)`
-					yield getProblem(parent, 'dirname');
-				}
-			}
-		}
-
-		/**
-		@param { import('estree').Node} node
-		@param {'dirname' | 'filename'} name
-		*/
-		function getProblem(node, name) {
-			return {
-				node,
-				messageId: name === 'dirname' ? ERROR_DIRNAME : ERROR_FILENAME,
-				fix: fixer => fixer.replaceText(node, `import.meta.${name}`),
-			};
-		}
-	});
-}
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `import.meta.{dirname,filename}` over legacy techniques for getting file paths.',
-			recommended: false,
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,111 +0,0 @@
-import {
-	checkVueTemplate,
-	isMethodNamed,
-	getTokenStore,
-} from './utils/index.js';
-import simpleArraySearchRule from './shared/simple-array-search-rule.js';
-import {isLiteral, isNegativeOne} from './ast/index.js';
-
-const MESSAGE_ID = 'prefer-includes';
-const messages = {
-	[MESSAGE_ID]: 'Use `.includes()`, rather than `.{{method}}()`, when checking for existence.',
-};
-// Ignore `{_,lodash,underscore}.{indexOf,lastIndexOf}`
-const ignoredVariables = new Set(['_', 'lodash', 'underscore']);
-const isIgnoredTarget = node => node.type === 'Identifier' && ignoredVariables.has(node.name);
-const isLiteralZero = node => isLiteral(node, 0);
-const isNegativeResult = node => ['===', '==', '<'].includes(node.operator);
-
-const getProblem = (context, node, target, argumentsNodes) => {
-	const {sourceCode} = context;
-	const tokenStore = getTokenStore(context, target);
-
-	const memberExpressionNode = target.parent;
-	const dotToken = tokenStore.getTokenBefore(memberExpressionNode.property);
-	const targetSource = sourceCode.getText().slice(
-		sourceCode.getRange(memberExpressionNode)[0],
-		sourceCode.getRange(dotToken)[0],
-	);
-
-	// Strip default `fromIndex`
-	if (isLiteralZero(argumentsNodes[1])) {
-		argumentsNodes = argumentsNodes.slice(0, 1);
-	}
-
-	const argumentsSource = argumentsNodes.map(argument => sourceCode.getText(argument));
-
-	return {
-		node: memberExpressionNode.property,
-		messageId: MESSAGE_ID,
-		data: {
-			method: node.left.callee.property.name,
-		},
-		fix(fixer) {
-			const replacement = `${isNegativeResult(node) ? '!' : ''}${targetSource}.includes(${argumentsSource.join(', ')})`;
-			return fixer.replaceText(node, replacement);
-		},
-	};
-};
-
-const includesOverSomeRule = simpleArraySearchRule({
-	method: 'some',
-	replacement: 'includes',
-});
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	includesOverSomeRule.listen(context);
-
-	context.on('BinaryExpression', node => {
-		const {left, right, operator} = node;
-
-		if (!isMethodNamed(left, 'indexOf') && !isMethodNamed(left, 'lastIndexOf')) {
-			return;
-		}
-
-		const target = left.callee.object;
-
-		if (isIgnoredTarget(target)) {
-			return;
-		}
-
-		const {arguments: argumentsNodes} = left;
-
-		// Ignore something.indexOf(foo, 0, another)
-		if (argumentsNodes.length > 2) {
-			return;
-		}
-
-		if (
-			(['!==', '!=', '>', '===', '=='].includes(operator) && isNegativeOne(right))
-			|| (['>=', '<'].includes(operator) && isLiteralZero(right))
-		) {
-			return getProblem(
-				context,
-				node,
-				target,
-				argumentsNodes,
-			);
-		}
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create: checkVueTemplate(create),
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `.includes()` over `.indexOf()`, `.lastIndexOf()`, and `Array#some()` when checking for existence or non-existence.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages: {
-			...messages,
-			...includesOverSomeRule.messages,
-		},
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/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 => ({
-	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;