@alexlit/lint-kit 176.0.0 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-new-array.js

@@ -1,106 +0,0 @@
-import {isParenthesized, getStaticValue} from '@eslint-community/eslint-utils';
-import needsSemicolon from './utils/needs-semicolon.js';
-import isNumber from './utils/is-number.js';
-import {isNewExpression} from './ast/index.js';
-
-const MESSAGE_ID_ERROR = 'error';
-const MESSAGE_ID_LENGTH = 'array-length';
-const MESSAGE_ID_ONLY_ELEMENT = 'only-element';
-const MESSAGE_ID_SPREAD = 'spread';
-const messages = {
-	[MESSAGE_ID_ERROR]: '`new Array()` is unclear in intent; use either `[x]` or `Array.from({length: x})`',
-	[MESSAGE_ID_LENGTH]: 'The argument is the length of array.',
-	[MESSAGE_ID_ONLY_ELEMENT]: 'The argument is the only element of array.',
-	[MESSAGE_ID_SPREAD]: 'Spread the argument.',
-};
-
-function getProblem(context, node) {
-	if (
-		!isNewExpression(node, {
-			name: 'Array',
-			argumentsLength: 1,
-			allowSpreadElement: true,
-		})
-	) {
-		return;
-	}
-
-	const problem = {
-		node,
-		messageId: MESSAGE_ID_ERROR,
-	};
-
-	const [argumentNode] = node.arguments;
-
-	const {sourceCode} = context;
-	let text = sourceCode.getText(argumentNode);
-	if (isParenthesized(argumentNode, sourceCode)) {
-		text = `(${text})`;
-	}
-
-	const maybeSemiColon = needsSemicolon(sourceCode.getTokenBefore(node), context, '[')
-		? ';'
-		: '';
-
-	// We are not sure how many `arguments` passed
-	if (argumentNode.type === 'SpreadElement') {
-		problem.suggest = [
-			{
-				messageId: MESSAGE_ID_SPREAD,
-				fix: fixer => fixer.replaceText(node, `${maybeSemiColon}[${text}]`),
-			},
-		];
-		return problem;
-	}
-
-	const fromLengthText = `Array.from(${text === 'length' ? '{length}' : `{length: ${text}}`})`;
-	const scope = sourceCode.getScope(node);
-	if (isNumber(argumentNode, scope)) {
-		problem.fix = fixer => fixer.replaceText(node, fromLengthText);
-		return problem;
-	}
-
-	const onlyElementText = `${maybeSemiColon}[${text}]`;
-	const result = getStaticValue(argumentNode, scope);
-	if (result !== null && typeof result.value !== 'number') {
-		problem.fix = fixer => fixer.replaceText(node, onlyElementText);
-		return problem;
-	}
-
-	// We don't know the argument is number or not
-	problem.suggest = [
-		{
-			messageId: MESSAGE_ID_LENGTH,
-			fix: fixer => fixer.replaceText(node, fromLengthText),
-		},
-		{
-			messageId: MESSAGE_ID_ONLY_ELEMENT,
-			fix: fixer => fixer.replaceText(node, onlyElementText),
-		},
-	];
-	return problem;
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	NewExpression(node) {
-		return getProblem(context, node);
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow `new Array()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-new-buffer.js

@@ -1,100 +0,0 @@
-import {getStaticValue} from '@eslint-community/eslint-utils';
-import {switchNewExpressionToCallExpression} from './fix/index.js';
-import isNumber from './utils/is-number.js';
-import {isNewExpression} from './ast/index.js';
-
-const ERROR = 'error';
-const ERROR_UNKNOWN = 'error-unknown';
-const SUGGESTION = 'suggestion';
-const messages = {
-	[ERROR]: '`new Buffer()` is deprecated, use `Buffer.{{method}}()` instead.',
-	[ERROR_UNKNOWN]: '`new Buffer()` is deprecated, use `Buffer.alloc()` or `Buffer.from()` instead.',
-	[SUGGESTION]: 'Switch to `Buffer.{{replacement}}()`.',
-};
-
-const inferMethod = (bufferArguments, scope) => {
-	if (bufferArguments.length !== 1) {
-		return 'from';
-	}
-
-	const [firstArgument] = bufferArguments;
-	if (firstArgument.type === 'SpreadElement') {
-		return;
-	}
-
-	if (firstArgument.type === 'ArrayExpression' || firstArgument.type === 'TemplateLiteral') {
-		return 'from';
-	}
-
-	if (isNumber(firstArgument, scope)) {
-		return 'alloc';
-	}
-
-	const staticResult = getStaticValue(firstArgument, scope);
-	if (staticResult) {
-		const {value} = staticResult;
-		if (
-			typeof value === 'string'
-			|| Array.isArray(value)
-		) {
-			return 'from';
-		}
-	}
-};
-
-function fix(node, context, method) {
-	return function * (fixer) {
-		yield fixer.insertTextAfter(node.callee, `.${method}`);
-		yield switchNewExpressionToCallExpression(node, context, fixer);
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-	return {
-		NewExpression(node) {
-			if (!isNewExpression(node, {name: 'Buffer'})) {
-				return;
-			}
-
-			const method = inferMethod(node.arguments, sourceCode.getScope(node));
-
-			if (method) {
-				return {
-					node,
-					messageId: ERROR,
-					data: {method},
-					fix: fix(node, context, method),
-				};
-			}
-
-			return {
-				node,
-				messageId: ERROR_UNKNOWN,
-				suggest: ['from', 'alloc'].map(replacement => ({
-					messageId: SUGGESTION,
-					data: {replacement},
-					fix: fix(node, context, replacement),
-				})),
-			};
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Enforce the use of `Buffer.from()` and `Buffer.alloc()` instead of the deprecated `new Buffer()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-null.js

@@ -1,153 +0,0 @@
-import {isMethodCall, isCallExpression, isLiteral} from './ast/index.js';
-
-const ERROR_MESSAGE_ID = 'error';
-const SUGGESTION_REPLACE_MESSAGE_ID = 'replace';
-const SUGGESTION_REMOVE_MESSAGE_ID = 'remove';
-const messages = {
-	[ERROR_MESSAGE_ID]: 'Use `undefined` instead of `null`.',
-	[SUGGESTION_REPLACE_MESSAGE_ID]: 'Replace `null` with `undefined`.',
-	[SUGGESTION_REMOVE_MESSAGE_ID]: 'Remove `null`.',
-};
-
-const isLooseEqual = node => node.type === 'BinaryExpression' && ['==', '!='].includes(node.operator);
-const isStrictEqual = node => node.type === 'BinaryExpression' && ['===', '!=='].includes(node.operator);
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {checkStrictEquality} = {
-		checkStrictEquality: false,
-		...context.options[0],
-	};
-
-	return {
-		Literal(node) {
-			if (
-				// eslint-disable-next-line unicorn/no-null
-				!isLiteral(node, null)
-				|| (!checkStrictEquality && isStrictEqual(node.parent))
-				// `Object.create(null)`, `Object.create(null, foo)`
-				|| (
-					isMethodCall(node.parent, {
-						object: 'Object',
-						method: 'create',
-						minimumArguments: 1,
-						maximumArguments: 2,
-						optionalCall: false,
-						optionalMember: false,
-					})
-					&& node.parent.arguments[0] === node
-				)
-				// `useRef(null)`
-				|| (
-					isCallExpression(node.parent, {
-						name: 'useRef',
-						argumentsLength: 1,
-						optionalCall: false,
-						optionalMember: false,
-					})
-					&& node.parent.arguments[0] === node
-				)
-				// `React.useRef(null)`
-				|| (
-					isMethodCall(node.parent, {
-						object: 'React',
-						method: 'useRef',
-						argumentsLength: 1,
-						optionalCall: false,
-						optionalMember: false,
-					})
-					&& node.parent.arguments[0] === node
-				)
-				// `foo.insertBefore(bar, null)`
-				|| (
-					isMethodCall(node.parent, {
-						method: 'insertBefore',
-						argumentsLength: 2,
-						optionalCall: false,
-					})
-					&& node.parent.arguments[1] === node
-				)
-			) {
-				return;
-			}
-
-			const {parent} = node;
-
-			const problem = {
-				node,
-				messageId: ERROR_MESSAGE_ID,
-			};
-
-			const useUndefinedFix = fixer => fixer.replaceText(node, 'undefined');
-
-			if (isLooseEqual(parent)) {
-				problem.fix = useUndefinedFix;
-				return problem;
-			}
-
-			const useUndefinedSuggestion = {
-				messageId: SUGGESTION_REPLACE_MESSAGE_ID,
-				fix: useUndefinedFix,
-			};
-
-			if (parent.type === 'ReturnStatement' && parent.argument === node) {
-				problem.suggest = [
-					{
-						messageId: SUGGESTION_REMOVE_MESSAGE_ID,
-						fix: fixer => fixer.remove(node),
-					},
-					useUndefinedSuggestion,
-				];
-				return problem;
-			}
-
-			if (parent.type === 'VariableDeclarator' && parent.init === node && parent.parent.kind !== 'const') {
-				const {sourceCode} = context;
-				const [, start] = sourceCode.getRange(parent.id);
-				const [, end] = sourceCode.getRange(node);
-				problem.suggest = [
-					{
-						messageId: SUGGESTION_REMOVE_MESSAGE_ID,
-						fix: fixer => fixer.removeRange([start, end]),
-					},
-					useUndefinedSuggestion,
-				];
-				return problem;
-			}
-
-			problem.suggest = [useUndefinedSuggestion];
-			return problem;
-		},
-	};
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			checkStrictEquality: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow the use of the `null` literal.',
-			recommended: true,
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [{checkStrictEquality: false}],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-object-as-default-parameter.js

@@ -1,52 +0,0 @@
-import {isFunction} from './ast/index.js';
-
-const MESSAGE_ID_IDENTIFIER = 'identifier';
-const MESSAGE_ID_NON_IDENTIFIER = 'non-identifier';
-const messages = {
-	[MESSAGE_ID_IDENTIFIER]: 'Do not use an object literal as default for parameter `{{parameter}}`.',
-	[MESSAGE_ID_NON_IDENTIFIER]: 'Do not use an object literal as default.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = () => ({
-	AssignmentPattern(node) {
-		if (!(
-			node.right.type === 'ObjectExpression'
-			&& node.right.properties.length > 0
-			&& isFunction(node.parent)
-			&& node.parent.params.includes(node)
-		)) {
-			return;
-		}
-
-		const {left, right} = node;
-
-		if (left.type === 'Identifier') {
-			return {
-				node: left,
-				messageId: MESSAGE_ID_IDENTIFIER,
-				data: {parameter: left.name},
-			};
-		}
-
-		return {
-			node: right,
-			messageId: MESSAGE_ID_NON_IDENTIFIER,
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow the use of objects as default parameters.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-process-exit.js

@@ -1,106 +0,0 @@
-import {isStaticRequire, isMethodCall, isLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'no-process-exit';
-const messages = {
-	[MESSAGE_ID]: 'Only use `process.exit()` in CLI apps. Throw an error instead.',
-};
-
-const isWorkerThreads = node =>
-	isLiteral(node, 'node:worker_threads')
-	|| isLiteral(node, 'worker_threads');
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const startsWithHashBang = context.sourceCode.lines[0].indexOf('#!') === 0;
-
-	if (startsWithHashBang) {
-		return {};
-	}
-
-	let processEventHandler;
-
-	// Only report if it's outside an worker thread context. See #328.
-	let requiredWorkerThreadsModule = false;
-	const problemNodes = [];
-
-	// `require('worker_threads')`
-	context.on('CallExpression', callExpression => {
-		if (
-			isStaticRequire(callExpression)
-			&& isWorkerThreads(callExpression.arguments[0])
-		) {
-			requiredWorkerThreadsModule = true;
-		}
-	});
-
-	// `import workerThreads from 'worker_threads'`
-	context.on('ImportDeclaration', importDeclaration => {
-		if (
-			importDeclaration.source.type === 'Literal'
-			&& isWorkerThreads(importDeclaration.source)
-		) {
-			requiredWorkerThreadsModule = true;
-		}
-	});
-
-	// Check `process.on` / `process.once` call
-	context.on('CallExpression', node => {
-		if (isMethodCall(node, {
-			object: 'process',
-			methods: ['on', 'once'],
-			minimumArguments: 1,
-			optionalCall: false,
-			optionalMember: false,
-		})) {
-			processEventHandler = node;
-		}
-	});
-	context.onExit('CallExpression', node => {
-		if (node === processEventHandler) {
-			processEventHandler = undefined;
-		}
-	});
-
-	// Check `process.exit` call
-	context.on('CallExpression', node => {
-		if (
-			!processEventHandler
-			&& isMethodCall(node, {
-				object: 'process',
-				method: 'exit',
-				optionalCall: false,
-				optionalMember: false,
-			})
-		) {
-			problemNodes.push(node);
-		}
-	});
-
-	context.onExit('Program', function * () {
-		if (requiredWorkerThreadsModule) {
-			return;
-		}
-
-		for (const node of problemNodes) {
-			yield {
-				node,
-				messageId: MESSAGE_ID,
-			};
-		}
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow `process.exit()`.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-single-promise-in-promise-methods.js

@@ -1,179 +0,0 @@
-import {isCommaToken} from '@eslint-community/eslint-utils';
-import {isMethodCall, isExpressionStatement} from './ast/index.js';
-import {
-	getParenthesizedText,
-	isParenthesized,
-	needsSemicolon,
-	shouldAddParenthesesToAwaitExpressionArgument,
-} from './utils/index.js';
-
-const MESSAGE_ID_ERROR = 'no-single-promise-in-promise-methods/error';
-const MESSAGE_ID_SUGGESTION_UNWRAP = 'no-single-promise-in-promise-methods/unwrap';
-const MESSAGE_ID_SUGGESTION_SWITCH_TO_PROMISE_RESOLVE = 'no-single-promise-in-promise-methods/use-promise-resolve';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Wrapping single-element array with `Promise.{{method}}()` is unnecessary.',
-	[MESSAGE_ID_SUGGESTION_UNWRAP]: 'Use the value directly.',
-	[MESSAGE_ID_SUGGESTION_SWITCH_TO_PROMISE_RESOLVE]: 'Switch to `Promise.resolve(…)`.',
-};
-const METHODS = ['all', 'any', 'race'];
-
-const isPromiseMethodCallWithSingleElementArray = node =>
-	isMethodCall(node, {
-		object: 'Promise',
-		methods: METHODS,
-		optionalMember: false,
-		optionalCall: false,
-		argumentsLength: 1,
-	})
-	&& node.arguments[0].type === 'ArrayExpression'
-	&& node.arguments[0].elements.length === 1
-	&& node.arguments[0].elements[0]
-	&& node.arguments[0].elements[0].type !== 'SpreadElement';
-
-const unwrapAwaitedCallExpression = (callExpression, context) => fixer => {
-	const {sourceCode} = context;
-	const [promiseNode] = callExpression.arguments[0].elements;
-	let text = getParenthesizedText(promiseNode, context);
-
-	if (
-		!isParenthesized(promiseNode, sourceCode)
-		&& shouldAddParenthesesToAwaitExpressionArgument(promiseNode)
-	) {
-		text = `(${text})`;
-	}
-
-	// The next node is already behind a `CallExpression`, there should be no ASI problem
-
-	return fixer.replaceText(callExpression, text);
-};
-
-const unwrapNonAwaitedCallExpression = (callExpression, context) => fixer => {
-	const {sourceCode} = context;
-	const [promiseNode] = callExpression.arguments[0].elements;
-	let text = getParenthesizedText(promiseNode, context);
-
-	if (
-		!isParenthesized(promiseNode, sourceCode)
-		// Since the original call expression can be anywhere, it's hard to tell if the promise
-		// need to be parenthesized, but it's safe to add parentheses
-		&& !(
-			// Known cases that not need parentheses
-			promiseNode.type === 'Identifier'
-			|| promiseNode.type === 'MemberExpression'
-		)
-	) {
-		text = `(${text})`;
-	}
-
-	const previousToken = sourceCode.getTokenBefore(callExpression);
-	if (needsSemicolon(previousToken, context, text)) {
-		text = `;${text}`;
-	}
-
-	return fixer.replaceText(callExpression, text);
-};
-
-const switchToPromiseResolve = (callExpression, sourceCode) => function * (fixer) {
-	/*
-	```
-	Promise.race([promise,])
-	//      ^^^^ methodNameNode
-	```
-	*/
-	const methodNameNode = callExpression.callee.property;
-	yield fixer.replaceText(methodNameNode, 'resolve');
-
-	const [arrayExpression] = callExpression.arguments;
-	/*
-	```
-	Promise.race([promise,])
-	//           ^ openingBracketToken
-	```
-	*/
-	const openingBracketToken = sourceCode.getFirstToken(arrayExpression);
-	/*
-	```
-	Promise.race([promise,])
-	//                   ^ penultimateToken
-	//                    ^ closingBracketToken
-	```
-	*/
-	const [
-		penultimateToken,
-		closingBracketToken,
-	] = sourceCode.getLastTokens(arrayExpression, 2);
-
-	yield fixer.remove(openingBracketToken);
-	yield fixer.remove(closingBracketToken);
-
-	if (isCommaToken(penultimateToken)) {
-		yield fixer.remove(penultimateToken);
-	}
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(callExpression) {
-		if (!isPromiseMethodCallWithSingleElementArray(callExpression)) {
-			return;
-		}
-
-		const methodName = callExpression.callee.property.name;
-
-		const problem = {
-			node: callExpression.arguments[0],
-			messageId: MESSAGE_ID_ERROR,
-			data: {
-				method: methodName,
-			},
-		};
-
-		const {sourceCode} = context;
-
-		if (
-			callExpression.parent.type === 'AwaitExpression'
-			&& callExpression.parent.argument === callExpression
-			&& (
-				methodName !== 'all'
-				|| isExpressionStatement(callExpression.parent.parent)
-			)
-		) {
-			problem.fix = unwrapAwaitedCallExpression(callExpression, context);
-			return problem;
-		}
-
-		if (methodName === 'all') {
-			return problem;
-		}
-
-		problem.suggest = [
-			{
-				messageId: MESSAGE_ID_SUGGESTION_UNWRAP,
-				fix: unwrapNonAwaitedCallExpression(callExpression, context),
-			},
-			{
-				messageId: MESSAGE_ID_SUGGESTION_SWITCH_TO_PROMISE_RESOLVE,
-				fix: switchToPromiseResolve(callExpression, sourceCode),
-			},
-		];
-
-		return problem;
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow passing single-element arrays to `Promise` methods.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;