@alexlit/lint-kit 176.0.1 → 177.0.0

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

@@ -1,521 +0,0 @@
-import {getStaticValue, isCommaToken, hasSideEffect} from '@eslint-community/eslint-utils';
-import {
-	getParenthesizedRange,
-	getParenthesizedText,
-	needsSemicolon,
-	isNodeMatches,
-	isMethodNamed,
-	hasOptionalChainElement,
-} from './utils/index.js';
-import {removeMethodCall} from './fix/index.js';
-import {isLiteral, isMethodCall} from './ast/index.js';
-
-const ERROR_ARRAY_FROM = 'array-from';
-const ERROR_ARRAY_CONCAT = 'array-concat';
-const ERROR_ARRAY_SLICE = 'array-slice';
-const ERROR_ARRAY_TO_SPLICED = 'array-to-spliced';
-const ERROR_STRING_SPLIT = 'string-split';
-const SUGGESTION_CONCAT_ARGUMENT_IS_SPREADABLE = 'argument-is-spreadable';
-const SUGGESTION_CONCAT_ARGUMENT_IS_NOT_SPREADABLE = 'argument-is-not-spreadable';
-const SUGGESTION_CONCAT_TEST_ARGUMENT = 'test-argument';
-const SUGGESTION_CONCAT_SPREAD_ALL_ARGUMENTS = 'spread-all-arguments';
-const SUGGESTION_USE_SPREAD = 'use-spread';
-const messages = {
-	[ERROR_ARRAY_FROM]: 'Prefer the spread operator over `Array.from(…)`.',
-	[ERROR_ARRAY_CONCAT]: 'Prefer the spread operator over `Array#concat(…)`.',
-	[ERROR_ARRAY_SLICE]: 'Prefer the spread operator over `Array#slice()`.',
-	[ERROR_ARRAY_TO_SPLICED]: 'Prefer the spread operator over `Array#toSpliced()`.',
-	[ERROR_STRING_SPLIT]: 'Prefer the spread operator over `String#split(\'\')`.',
-	[SUGGESTION_CONCAT_ARGUMENT_IS_SPREADABLE]: 'First argument is an `array`.',
-	[SUGGESTION_CONCAT_ARGUMENT_IS_NOT_SPREADABLE]: 'First argument is not an `array`.',
-	[SUGGESTION_CONCAT_TEST_ARGUMENT]: 'Test first argument with `Array.isArray(…)`.',
-	[SUGGESTION_CONCAT_SPREAD_ALL_ARGUMENTS]: 'Spread all unknown arguments`.',
-	[SUGGESTION_USE_SPREAD]: 'Use `...` operator.',
-};
-
-const ignoredSliceCallee = [
-	'arrayBuffer',
-	'blob',
-	'buffer',
-	'file',
-	'this',
-];
-
-const isArrayLiteral = node => node.type === 'ArrayExpression';
-const isArrayLiteralHasTrailingComma = (node, sourceCode) => {
-	if (node.elements.length === 0) {
-		return false;
-	}
-
-	return isCommaToken(sourceCode.getLastToken(node, 1));
-};
-
-function fixConcat(node, context, fixableArguments) {
-	const {sourceCode} = context;
-	const array = node.callee.object;
-	const concatCallArguments = node.arguments;
-	const arrayParenthesizedRange = getParenthesizedRange(array, context);
-	const arrayIsArrayLiteral = isArrayLiteral(array);
-	const arrayHasTrailingComma = arrayIsArrayLiteral && isArrayLiteralHasTrailingComma(array, sourceCode);
-
-	const getArrayLiteralElementsText = (node, keepTrailingComma) => {
-		if (
-			!keepTrailingComma
-			&& isArrayLiteralHasTrailingComma(node, sourceCode)
-		) {
-			const start = sourceCode.getRange(node)[0] + 1;
-			const [end] = sourceCode.getRange(sourceCode.getLastToken(node, 1));
-			return sourceCode.text.slice(start, end);
-		}
-
-		return sourceCode.getText(node, -1, -1);
-	};
-
-	const getFixedText = () => {
-		const nonEmptyArguments = fixableArguments
-			.filter(({node, isArrayLiteral}) => (!isArrayLiteral || node.elements.length > 0));
-		const lastArgument = nonEmptyArguments.at(-1);
-
-		let text = nonEmptyArguments
-			.map(({node, isArrayLiteral, isSpreadable, testArgument}) => {
-				if (isArrayLiteral) {
-					return getArrayLiteralElementsText(node, node === lastArgument.node);
-				}
-
-				let text = getParenthesizedText(node, context);
-
-				if (testArgument) {
-					return `...(Array.isArray(${text}) ? ${text} : [${text}])`;
-				}
-
-				if (isSpreadable) {
-					text = `...${text}`;
-				}
-
-				return text || ' ';
-			})
-			.join(', ');
-
-		if (!text) {
-			return '';
-		}
-
-		if (arrayIsArrayLiteral) {
-			if (array.elements.length > 0) {
-				text = ` ${text}`;
-
-				if (!arrayHasTrailingComma) {
-					text = `,${text}`;
-				}
-
-				if (
-					arrayHasTrailingComma
-					&& (!lastArgument.isArrayLiteral || !isArrayLiteralHasTrailingComma(lastArgument.node, sourceCode))
-				) {
-					text = `${text},`;
-				}
-			}
-		} else {
-			text = `, ${text}`;
-		}
-
-		return text;
-	};
-
-	function removeArguments(fixer) {
-		const [firstArgument] = concatCallArguments;
-		const lastArgument = concatCallArguments[fixableArguments.length - 1];
-
-		const [start] = getParenthesizedRange(firstArgument, context);
-		let [, end] = sourceCode.getRange(sourceCode.getTokenAfter(lastArgument, isCommaToken));
-
-		const textAfter = sourceCode.text.slice(end);
-		const [leadingSpaces] = textAfter.match(/^\s*/);
-		end += leadingSpaces.length;
-
-		return fixer.removeRange([start, end]);
-	}
-
-	return function * (fixer) {
-		// Fixed code always starts with `[`
-		if (
-			!arrayIsArrayLiteral
-			&& needsSemicolon(sourceCode.getTokenBefore(node), context, '[')
-		) {
-			yield fixer.insertTextBefore(node, ';');
-		}
-
-		yield (
-			concatCallArguments.length - fixableArguments.length === 0
-				? removeMethodCall(fixer, node, context)
-				: removeArguments(fixer)
-		);
-
-		const text = getFixedText();
-
-		if (arrayIsArrayLiteral) {
-			const closingBracketToken = sourceCode.getLastToken(array);
-			yield fixer.insertTextBefore(closingBracketToken, text);
-		} else {
-			// The array is already accessing `.concat`, there should not any case need add extra `()`
-			yield fixer.insertTextBeforeRange(arrayParenthesizedRange, '[...');
-			yield fixer.insertTextAfterRange(arrayParenthesizedRange, text);
-			yield fixer.insertTextAfterRange(arrayParenthesizedRange, ']');
-		}
-	};
-}
-
-const getConcatArgumentSpreadable = (node, scope) => {
-	if (node.type === 'SpreadElement') {
-		return;
-	}
-
-	if (isArrayLiteral(node)) {
-		return {node, isArrayLiteral: true};
-	}
-
-	const result = getStaticValue(node, scope);
-
-	if (!result) {
-		return;
-	}
-
-	const isSpreadable = Array.isArray(result.value);
-
-	return {node, isSpreadable};
-};
-
-function getConcatFixableArguments(argumentsList, scope) {
-	const fixableArguments = [];
-
-	for (const node of argumentsList) {
-		const result = getConcatArgumentSpreadable(node, scope);
-
-		if (result) {
-			fixableArguments.push(result);
-		} else {
-			break;
-		}
-	}
-
-	return fixableArguments;
-}
-
-function fixArrayFrom(node, context) {
-	const {sourceCode} = context;
-	const [object] = node.arguments;
-
-	function getObjectText() {
-		if (isArrayLiteral(object)) {
-			return sourceCode.getText(object);
-		}
-
-		const [start, end] = getParenthesizedRange(object, context);
-		const text = sourceCode.text.slice(start, end);
-
-		return `[...${text}]`;
-	}
-
-	return function * (fixer) {
-		// Fixed code always starts with `[`
-		if (needsSemicolon(sourceCode.getTokenBefore(node), context, '[')) {
-			yield fixer.insertTextBefore(node, ';');
-		}
-
-		const objectText = getObjectText();
-
-		yield fixer.replaceText(node, objectText);
-	};
-}
-
-function methodCallToSpread(node, context) {
-	return function * (fixer) {
-		const {sourceCode} = context;
-		// Fixed code always starts with `[`
-		if (needsSemicolon(sourceCode.getTokenBefore(node), context, '[')) {
-			yield fixer.insertTextBefore(node, ';');
-		}
-
-		yield fixer.insertTextBefore(node, '[...');
-		yield fixer.insertTextAfter(node, ']');
-
-		// The array is already accessing `.slice` or `.split`, there should not any case need add extra `()`
-
-		yield removeMethodCall(fixer, node, context);
-	};
-}
-
-function isClassName(node) {
-	if (node.type === 'MemberExpression') {
-		node = node.property;
-	}
-
-	if (node.type !== 'Identifier') {
-		return false;
-	}
-
-	const {name} = node;
-
-	return /^[A-Z]./.test(name) && name.toUpperCase() !== name;
-}
-
-function isNotArray(node, scope) {
-	if (
-		node.type === 'TemplateLiteral'
-		|| node.type === 'Literal'
-		|| node.type === 'BinaryExpression'
-		|| isClassName(node)
-		// `foo.join()`
-		|| (isMethodNamed(node, 'join') && node.arguments.length <= 1)
-	) {
-		return true;
-	}
-
-	const staticValue = getStaticValue(node, scope);
-	if (staticValue && !Array.isArray(staticValue.value)) {
-		return true;
-	}
-
-	return false;
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	// `Array.from()`
-	context.on('CallExpression', node => {
-		if (
-			isMethodCall(node, {
-				object: 'Array',
-				method: 'from',
-				argumentsLength: 1,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			// Allow `Array.from({length})`
-			&& node.arguments[0].type !== 'ObjectExpression'
-		) {
-			return {
-				node,
-				messageId: ERROR_ARRAY_FROM,
-				fix: fixArrayFrom(node, context),
-			};
-		}
-	});
-
-	// `array.concat()`
-	context.on('CallExpression', node => {
-		if (!isMethodCall(node, {
-			method: 'concat',
-			optionalCall: false,
-			optionalMember: false,
-		})) {
-			return;
-		}
-
-		const {object} = node.callee;
-		const scope = sourceCode.getScope(object);
-
-		if (isNotArray(object, scope)) {
-			return;
-		}
-
-		const staticResult = getStaticValue(object, scope);
-		if (staticResult && !Array.isArray(staticResult.value)) {
-			return;
-		}
-
-		const problem = {
-			node: node.callee.property,
-			messageId: ERROR_ARRAY_CONCAT,
-		};
-
-		const fixableArguments = getConcatFixableArguments(node.arguments, scope);
-
-		if (fixableArguments.length > 0 || node.arguments.length === 0) {
-			problem.fix = fixConcat(node, context, fixableArguments);
-			return problem;
-		}
-
-		const [firstArgument, ...restArguments] = node.arguments;
-		if (firstArgument.type === 'SpreadElement') {
-			return problem;
-		}
-
-		const fixableArgumentsAfterFirstArgument = getConcatFixableArguments(restArguments, scope);
-		const suggestions = [
-			{
-				messageId: SUGGESTION_CONCAT_ARGUMENT_IS_SPREADABLE,
-				isSpreadable: true,
-			},
-			{
-				messageId: SUGGESTION_CONCAT_ARGUMENT_IS_NOT_SPREADABLE,
-				isSpreadable: false,
-			},
-		];
-
-		if (!hasSideEffect(firstArgument, sourceCode)) {
-			suggestions.push({
-				messageId: SUGGESTION_CONCAT_TEST_ARGUMENT,
-				testArgument: true,
-			});
-		}
-
-		problem.suggest = suggestions.map(({messageId, isSpreadable, testArgument}) => ({
-			messageId,
-			fix: fixConcat(
-				node,
-				context,
-				// When apply suggestion, we also merge fixable arguments after the first one
-				[
-					{
-						node: firstArgument,
-						isSpreadable,
-						testArgument,
-					},
-					...fixableArgumentsAfterFirstArgument,
-				],
-			),
-		}));
-
-		if (
-			fixableArgumentsAfterFirstArgument.length < restArguments.length
-			&& restArguments.every(({type}) => type !== 'SpreadElement')
-		) {
-			problem.suggest.push({
-				messageId: SUGGESTION_CONCAT_SPREAD_ALL_ARGUMENTS,
-				fix: fixConcat(
-					node,
-					context,
-					node.arguments.map(node => getConcatArgumentSpreadable(node, scope) || {node, isSpreadable: true}),
-				),
-			});
-		}
-
-		return problem;
-	});
-
-	// `array.slice()`
-	context.on('CallExpression', node => {
-		if (!(
-			isMethodCall(node, {
-				method: 'slice',
-				minimumArguments: 0,
-				maximumArguments: 1,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& !isArrayLiteral(node.callee.object)
-			&& !hasOptionalChainElement(node.callee.object)
-		)) {
-			return;
-		}
-
-		if (isNodeMatches(node.callee.object, ignoredSliceCallee)) {
-			return;
-		}
-
-		const [firstArgument] = node.arguments;
-		if (firstArgument && !isLiteral(firstArgument, 0)) {
-			return;
-		}
-
-		return {
-			node: node.callee.property,
-			messageId: ERROR_ARRAY_SLICE,
-			fix: methodCallToSpread(node, context),
-		};
-	});
-
-	// `array.toSpliced()`
-	context.on('CallExpression', node => {
-		if (!(
-			isMethodCall(node, {
-				method: 'toSpliced',
-				argumentsLength: 0,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& node.callee.object.type !== 'ArrayExpression'
-		)) {
-			return;
-		}
-
-		return {
-			node: node.callee.property,
-			messageId: ERROR_ARRAY_TO_SPLICED,
-			fix: methodCallToSpread(node, context),
-		};
-	});
-
-	// `string.split()`
-	context.on('CallExpression', node => {
-		if (!isMethodCall(node, {
-			method: 'split',
-			argumentsLength: 1,
-			optionalCall: false,
-			optionalMember: false,
-		})) {
-			return;
-		}
-
-		const [separator] = node.arguments;
-		if (!isLiteral(separator, '')) {
-			return;
-		}
-
-		const string = node.callee.object;
-		const staticValue = getStaticValue(string, sourceCode.getScope(string));
-		let hasSameResult = false;
-		if (staticValue) {
-			const {value} = staticValue;
-
-			if (typeof value !== 'string') {
-				return;
-			}
-
-			// eslint-disable-next-line unicorn/prefer-spread
-			const resultBySplit = value.split('');
-			const resultBySpread = [...value];
-
-			hasSameResult = resultBySplit.length === resultBySpread.length
-				&& resultBySplit.every((character, index) => character === resultBySpread[index]);
-		}
-
-		const problem = {
-			node: node.callee.property,
-			messageId: ERROR_STRING_SPLIT,
-		};
-
-		if (hasSameResult) {
-			problem.fix = methodCallToSpread(node, context);
-		} else {
-			problem.suggest = [
-				{
-					messageId: SUGGESTION_USE_SPREAD,
-					fix: methodCallToSpread(node, context),
-				},
-			];
-		}
-
-		return problem;
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer the spread operator over `Array.from(…)`, `Array#concat(…)`, `Array#{slice,toSpliced}()` and `String#split(\'\')`.',
-			recommended: true,
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,149 +0,0 @@
-import {isStringLiteral, isDirective} from './ast/index.js';
-import {fixSpaceAroundKeyword, replaceTemplateElement} from './fix/index.js';
-
-const MESSAGE_ID = 'prefer-string-raw';
-const messages = {
-	[MESSAGE_ID]: '`String.raw` should be used to avoid escaping `\\`.',
-};
-
-const BACKSLASH = '\\';
-
-function unescapeBackslash(text, quote = '') {
-	return text.replaceAll(new RegExp(String.raw`\\(?<escapedCharacter>[\\${quote}])`, 'g'), '$<escapedCharacter>');
-}
-
-/**
-Check if a string literal is restricted to replace with a `String.raw`
-*/
-// eslint-disable-next-line complexity
-function isStringRawRestricted(node) {
-	const {parent} = node;
-	const {type} = parent;
-	return (
-		// Directive
-		isDirective(parent)
-		// Property, method, or accessor key (only non-computed)
-		|| (
-			(
-				type === 'Property'
-				|| type === 'PropertyDefinition'
-				|| type === 'MethodDefinition'
-				|| type === 'AccessorProperty'
-			)
-			&& !parent.computed && parent.key === node
-		)
-		// Property, method, or accessor key (always)
-		|| (
-			(
-				type === 'TSAbstractPropertyDefinition'
-				|| type === 'TSAbstractMethodDefinition'
-				|| type === 'TSAbstractAccessorProperty'
-				|| type === 'TSPropertySignature'
-			)
-			&& parent.key === node
-		)
-		// Module source
-		|| (
-			(
-				type === 'ImportDeclaration'
-				|| type === 'ExportNamedDeclaration'
-				|| type === 'ExportAllDeclaration'
-			) && parent.source === node
-		)
-		// Import attribute key and value
-		|| (type === 'ImportAttribute' && (parent.key === node || parent.value === node))
-		// Module specifier
-		|| (type === 'ImportSpecifier' && parent.imported === node)
-		|| (type === 'ExportSpecifier' && (parent.local === node || parent.exported === node))
-		|| (type === 'ExportAllDeclaration' && parent.exported === node)
-		// JSX attribute value
-		|| (type === 'JSXAttribute' && parent.value === node)
-		// (TypeScript) Enum member key and value
-		|| (type === 'TSEnumMember' && (parent.initializer === node || parent.id === node))
-		// (TypeScript) Module declaration
-		|| (type === 'TSModuleDeclaration' && parent.id === node)
-		// (TypeScript) CommonJS module reference
-		|| (type === 'TSExternalModuleReference' && parent.expression === node)
-		// (TypeScript) Literal type
-		|| (type === 'TSLiteralType' && parent.literal === node)
-	);
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('Literal', node => {
-		if (!isStringLiteral(node) || isStringRawRestricted(node)) {
-			return;
-		}
-
-		const {sourceCode} = context;
-		const {raw} = node;
-		if (
-			raw.at(-2) === BACKSLASH
-			|| !raw.includes(BACKSLASH + BACKSLASH)
-			|| raw.includes('`')
-			|| raw.includes('${')
-			|| sourceCode.getLoc(node).start.line !== sourceCode.getLoc(node).end.line
-		) {
-			return;
-		}
-
-		const unescaped = unescapeBackslash(raw.slice(1, -1), raw.charAt(0));
-		if (unescaped !== node.value) {
-			return;
-		}
-
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			* fix(fixer) {
-				yield fixSpaceAroundKeyword(fixer, node, context);
-				yield fixer.replaceText(node, `String.raw\`${unescaped}\``);
-			},
-		};
-	});
-
-	context.on('TemplateLiteral', node => {
-		if (
-			(node.parent.type === 'TaggedTemplateExpression' && node.parent.quasi === node)
-			|| node.quasis.every(({value: {cooked, raw}}) => cooked === raw)
-			|| node.quasis.some(({value: {cooked, raw}}) => cooked.at(-1) === BACKSLASH || unescapeBackslash(raw) !== cooked)
-		) {
-			return;
-		}
-
-		return {
-			node,
-			messageId: MESSAGE_ID,
-			* fix(fixer) {
-				yield fixSpaceAroundKeyword(fixer, node, context);
-				yield fixer.insertTextBefore(node, 'String.raw');
-
-				for (const quasis of node.quasis) {
-					const {cooked, raw} = quasis.value;
-					if (cooked === raw) {
-						continue;
-					}
-
-					yield replaceTemplateElement(quasis, cooked, context, fixer);
-				}
-			},
-		};
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer using the `String.raw` tag to avoid escaping `\\`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;