@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/simple-array-search-rule.js

@@ -1,126 +0,0 @@
-import {hasSideEffect, isParenthesized, findVariable} from '@eslint-community/eslint-utils';
-import {isMethodCall} from '../ast/index.js';
-import {isSameIdentifier, isFunctionSelfUsedInside} from '../utils/index.js';
-
-const isSimpleCompare = (node, compareNode) =>
-	node.type === 'BinaryExpression'
-	&& node.operator === '==='
-	&& (
-		isSameIdentifier(node.left, compareNode)
-		|| isSameIdentifier(node.right, compareNode)
-	);
-const isSimpleCompareCallbackFunction = node =>
-	// Matches `foo.findIndex(bar => bar === baz)`
-	(
-		node.type === 'ArrowFunctionExpression'
-		&& !node.async
-		&& node.params.length === 1
-		&& isSimpleCompare(node.body, node.params[0])
-	)
-	// Matches `foo.findIndex(bar => {return bar === baz})`
-	// Matches `foo.findIndex(function (bar) {return bar === baz})`
-	|| (
-		(node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression')
-		&& !node.async
-		&& !node.generator
-		&& node.params.length === 1
-		&& node.body.type === 'BlockStatement'
-		&& node.body.body.length === 1
-		&& node.body.body[0].type === 'ReturnStatement'
-		&& isSimpleCompare(node.body.body[0].argument, node.params[0])
-	);
-const isIdentifierNamed = ({type, name}, expectName) => type === 'Identifier' && name === expectName;
-
-export default function simpleArraySearchRule({method, replacement}) {
-	// Add prefix to avoid conflicts in `prefer-includes` rule
-	const MESSAGE_ID_PREFIX = `prefer-${replacement}-over-${method}/`;
-	const ERROR = `${MESSAGE_ID_PREFIX}error`;
-	const SUGGESTION = `${MESSAGE_ID_PREFIX}suggestion`;
-	const ERROR_MESSAGES = {
-		findIndex: 'Use `.indexOf()` instead of `.findIndex()` when looking for the index of an item.',
-		findLastIndex: 'Use `.lastIndexOf()` instead of `findLastIndex() when looking for the index of an item.`',
-		some: `Use \`.${replacement}()\` instead of \`.${method}()\` when checking value existence.`,
-	};
-
-	const messages = {
-		[ERROR]: ERROR_MESSAGES[method],
-		[SUGGESTION]: `Replace \`.${method}()\` with \`.${replacement}()\`.`,
-	};
-
-	function listen(context) {
-		const {sourceCode} = context;
-		const {scopeManager} = sourceCode;
-
-		context.on('CallExpression', callExpression => {
-			if (
-				!isMethodCall(callExpression, {
-					method,
-					argumentsLength: 1,
-					optionalCall: false,
-				})
-				|| !isSimpleCompareCallbackFunction(callExpression.arguments[0])
-			) {
-				return;
-			}
-
-			const [callback] = callExpression.arguments;
-			const binaryExpression = callback.body.type === 'BinaryExpression'
-				? callback.body
-				: callback.body.body[0].argument;
-			const [parameter] = callback.params;
-			const {left, right} = binaryExpression;
-			const {name} = parameter;
-
-			let searchValueNode;
-			let parameterInBinaryExpression;
-			if (isIdentifierNamed(left, name)) {
-				searchValueNode = right;
-				parameterInBinaryExpression = left;
-			} else if (isIdentifierNamed(right, name)) {
-				searchValueNode = left;
-				parameterInBinaryExpression = right;
-			} else {
-				return;
-			}
-
-			const callbackScope = scopeManager.acquire(callback);
-			if (
-				// Can't use scopeManager in vue template
-				// https://github.com/vuejs/vue-eslint-parser/issues/263
-				!callbackScope
-				// `parameter` is used somewhere else
-				|| findVariable(callbackScope, parameter).references.some(({identifier}) => identifier !== parameterInBinaryExpression)
-				|| isFunctionSelfUsedInside(callback, callbackScope)
-			) {
-				return;
-			}
-
-			const methodNode = callExpression.callee.property;
-			const problem = {
-				node: methodNode,
-				messageId: ERROR,
-				suggest: [],
-			};
-
-			const fix = function * (fixer) {
-				let text = sourceCode.getText(searchValueNode);
-				if (isParenthesized(searchValueNode, sourceCode) && !isParenthesized(callback, sourceCode)) {
-					text = `(${text})`;
-				}
-
-				yield fixer.replaceText(methodNode, replacement);
-				yield fixer.replaceText(callback, text);
-			};
-
-			if (hasSideEffect(searchValueNode, sourceCode)) {
-				problem.suggest.push({messageId: SUGGESTION, fix});
-			} else {
-				problem.fix = fix;
-			}
-
-			return problem;
-		});
-	}
-
-	return {messages, listen};
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/typed-array.js

@@ -1,17 +0,0 @@
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#description
-const typedArrayTypes = [
-	'Int8Array',
-	'Uint8Array',
-	'Uint8ClampedArray',
-	'Int16Array',
-	'Uint16Array',
-	'Int32Array',
-	'Uint32Array',
-	'Float16Array',
-	'Float32Array',
-	'Float64Array',
-	'BigInt64Array',
-	'BigUint64Array',
-];
-
-export default typedArrayTypes;

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

@@ -1,192 +0,0 @@
-import escapeString from './utils/escape-string.js';
-import escapeTemplateElementRaw from './utils/escape-template-element-raw.js';
-import {replaceTemplateElement} from './fix/index.js';
-
-const defaultMessage = 'Prefer `{{suggest}}` over `{{match}}`.';
-const SUGGESTION_MESSAGE_ID = 'replace';
-const messages = {
-	[SUGGESTION_MESSAGE_ID]: 'Replace `{{match}}` with `{{suggest}}`.',
-};
-
-const ignoredIdentifier = new Set([
-	'gql',
-	'html',
-	'svg',
-]);
-
-const ignoredMemberExpressionObject = new Set([
-	'styled',
-]);
-
-const isIgnoredTag = node => {
-	if (!node.parent || !node.parent.parent || !node.parent.parent.tag) {
-		return false;
-	}
-
-	const {tag} = node.parent.parent;
-
-	if (tag.type === 'Identifier' && ignoredIdentifier.has(tag.name)) {
-		return true;
-	}
-
-	if (tag.type === 'MemberExpression') {
-		const {object} = tag;
-		if (
-			object.type === 'Identifier'
-			&& ignoredMemberExpressionObject.has(object.name)
-		) {
-			return true;
-		}
-	}
-
-	return false;
-};
-
-function getReplacements(patterns) {
-	return Object.entries(patterns)
-		.map(([match, options]) => {
-			if (typeof options === 'string') {
-				options = {
-					suggest: options,
-				};
-			}
-
-			return {
-				match,
-				regex: new RegExp(match, 'gu'),
-				fix: true,
-				...options,
-			};
-		});
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {patterns} = {
-		patterns: {},
-		...context.options[0],
-	};
-	const replacements = getReplacements(patterns);
-
-	if (replacements.length === 0) {
-		return;
-	}
-
-	context.on(['Literal', 'TemplateElement'], node => {
-		const {type, value, raw} = node;
-
-		let string;
-		if (type === 'Literal') {
-			string = value;
-		} else if (!isIgnoredTag(node)) {
-			string = value.raw;
-		}
-
-		if (!string || typeof string !== 'string') {
-			return;
-		}
-
-		const replacement = replacements.find(({regex}) => regex.test(string));
-
-		if (!replacement) {
-			return;
-		}
-
-		const {fix: autoFix, message = defaultMessage, match, suggest, regex} = replacement;
-		const problem = {
-			node,
-			message,
-			data: {
-				match,
-				suggest,
-			},
-		};
-
-		const fixed = string.replace(regex, suggest);
-		const fix = type === 'Literal'
-			? fixer => {
-				const [quote] = raw;
-				return fixer.replaceText(
-					node,
-					node.parent.type === 'JSXAttribute' ? quote + fixed + quote : escapeString(fixed, quote),
-				);
-			}
-			: fixer => replaceTemplateElement(
-				node,
-				escapeTemplateElementRaw(fixed),
-				context,
-				fixer,
-			);
-
-		if (autoFix) {
-			problem.fix = fix;
-		} else {
-			problem.suggest = [
-				{
-					messageId: SUGGESTION_MESSAGE_ID,
-					fix,
-				},
-			];
-		}
-
-		return problem;
-	});
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			patterns: {
-				type: 'object',
-				additionalProperties: {
-					anyOf: [
-						{
-							type: 'string',
-						},
-						{
-							type: 'object',
-							required: [
-								'suggest',
-							],
-							properties: {
-								suggest: {
-									type: 'string',
-								},
-								fix: {
-									type: 'boolean',
-									// Default: true
-								},
-								message: {
-									type: 'string',
-									// Default: ''
-								},
-							},
-							additionalProperties: false,
-						},
-					],
-				},
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce better string content.',
-			recommended: false,
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,114 +0,0 @@
-import {isColonToken} from '@eslint-community/eslint-utils';
-import getSwitchCaseHeadLocation from './utils/get-switch-case-head-location.js';
-import getIndentString from './utils/get-indent-string.js';
-import {replaceNodeOrTokenAndSpacesBefore} from './fix/index.js';
-
-const MESSAGE_ID_EMPTY_CLAUSE = 'switch-case-braces/empty';
-const MESSAGE_ID_MISSING_BRACES = 'switch-case-braces/missing';
-const MESSAGE_ID_UNNECESSARY_BRACES = 'switch-case-braces/unnecessary';
-const messages = {
-	[MESSAGE_ID_EMPTY_CLAUSE]: 'Unexpected braces in empty case clause.',
-	[MESSAGE_ID_MISSING_BRACES]: 'Missing braces in case clause.',
-	[MESSAGE_ID_UNNECESSARY_BRACES]: 'Unnecessary braces in case clause.',
-};
-
-function * removeBraces(fixer, node, context) {
-	const {sourceCode} = context;
-	const [blockStatement] = node.consequent;
-	const openingBraceToken = sourceCode.getFirstToken(blockStatement);
-	yield replaceNodeOrTokenAndSpacesBefore(openingBraceToken, '', fixer, context);
-
-	const closingBraceToken = sourceCode.getLastToken(blockStatement);
-	yield fixer.remove(closingBraceToken);
-}
-
-function * addBraces(fixer, node, context) {
-	const {sourceCode} = context;
-	const colonToken = sourceCode.getTokenAfter(
-		node.test || sourceCode.getFirstToken(node),
-		isColonToken,
-	);
-	yield fixer.insertTextAfter(colonToken, ' {');
-
-	const lastToken = sourceCode.getLastToken(node);
-	const indent = getIndentString(node, context);
-	yield fixer.insertTextAfter(lastToken, `\n${indent}}`);
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const isBracesRequired = context.options[0] !== 'avoid';
-	const {sourceCode} = context;
-
-	return {
-		SwitchCase(node) {
-			const {consequent} = node;
-			if (consequent.length === 0) {
-				return;
-			}
-
-			if (
-				consequent.length === 1
-				&& consequent[0].type === 'BlockStatement'
-				&& consequent[0].body.length === 0
-			) {
-				return {
-					node,
-					loc: sourceCode.getLoc(sourceCode.getFirstToken(consequent[0])),
-					messageId: MESSAGE_ID_EMPTY_CLAUSE,
-					fix: fixer => removeBraces(fixer, node, context),
-				};
-			}
-
-			if (
-				isBracesRequired
-				&& !(
-					consequent.length === 1
-					&& consequent[0].type === 'BlockStatement'
-				)
-			) {
-				return {
-					node,
-					loc: getSwitchCaseHeadLocation(node, context),
-					messageId: MESSAGE_ID_MISSING_BRACES,
-					fix: fixer => addBraces(fixer, node, context),
-				};
-			}
-
-			if (
-				!isBracesRequired
-				&& consequent.length === 1
-				&& consequent[0].type === 'BlockStatement'
-				&& consequent[0].body.every(node =>
-					node.type !== 'VariableDeclaration'
-					&& node.type !== 'FunctionDeclaration',
-				)
-			) {
-				return {
-					node,
-					loc: sourceCode.getLoc(sourceCode.getFirstToken(consequent[0])),
-					messageId: MESSAGE_ID_UNNECESSARY_BRACES,
-					fix: fixer => removeBraces(fixer, node, context),
-				};
-			}
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'layout',
-		docs: {
-			description: 'Enforce consistent brace style for `case` clauses.',
-			recommended: true,
-		},
-		fixable: 'code',
-		schema: [{enum: ['always', 'avoid']}],
-		defaultOptions: ['always'],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/template-indent.js

@@ -1,219 +0,0 @@
-import stripIndent from 'strip-indent';
-import indentString from 'indent-string';
-import esquery from 'esquery';
-import {replaceTemplateElement} from './fix/index.js';
-import {isMethodCall, isCallExpression, isTaggedTemplateLiteral} from './ast/index.js';
-import {isNodeMatches} from './utils/index.js';
-
-const MESSAGE_ID_IMPROPERLY_INDENTED_TEMPLATE = 'template-indent';
-const messages = {
-	[MESSAGE_ID_IMPROPERLY_INDENTED_TEMPLATE]: 'Templates should be properly indented.',
-};
-
-const isJestInlineSnapshot = node =>
-	isMethodCall(node.parent, {
-		method: 'toMatchInlineSnapshot',
-		argumentsLength: 1,
-		optionalCall: false,
-		optionalMember: false,
-	})
-	&& node.parent.arguments[0] === node
-	&& isCallExpression(node.parent.callee.object, {
-		name: 'expect',
-		argumentsLength: 1,
-		optionalCall: false,
-		optionalMember: false,
-	});
-
-const parsedEsquerySelectors = new Map();
-const parseEsquerySelector = selector => {
-	if (!parsedEsquerySelectors.has(selector)) {
-		parsedEsquerySelectors.set(selector, esquery.parse(selector));
-	}
-
-	return parsedEsquerySelectors.get(selector);
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-	const options = {
-		tags: ['outdent', 'dedent', 'gql', 'sql', 'html', 'styled'],
-		functions: ['dedent', 'stripIndent'],
-		selectors: [],
-		comments: ['HTML', 'indent'],
-		...context.options[0],
-	};
-
-	options.comments = options.comments.map(comment => comment.toLowerCase());
-
-	/** @param {import('@babel/core').types.TemplateLiteral} node */
-	const getProblem = node => {
-		const delimiter = '__PLACEHOLDER__' + Math.random();
-		const joined = node.quasis
-			.map(quasi => {
-				const untrimmedText = sourceCode.getText(quasi);
-				return untrimmedText.slice(1, quasi.tail ? -1 : -2);
-			})
-			.join(delimiter);
-
-		const eolMatch = joined.match(/\r?\n/);
-		if (!eolMatch) {
-			return;
-		}
-
-		const eol = eolMatch[0];
-
-		const startLine = sourceCode.lines[sourceCode.getLoc(node).start.line - 1];
-		const marginMatch = startLine.match(/^(\s*)\S/);
-		const parentMargin = marginMatch ? marginMatch[1] : '';
-
-		let indent;
-		if (typeof options.indent === 'string') {
-			indent = options.indent;
-		} else if (typeof options.indent === 'number') {
-			indent = ' '.repeat(options.indent);
-		} else {
-			const tabs = parentMargin.startsWith('\t');
-			indent = tabs ? '\t' : '  ';
-		}
-
-		const dedented = stripIndent(joined);
-		const trimmed = dedented.replaceAll(new RegExp(`^${eol}|${eol}[ \t]*$`, 'g'), '');
-
-		const fixed
-			= eol
-				+ indentString(trimmed, 1, {indent: parentMargin + indent})
-				+ eol
-				+ parentMargin;
-
-		if (fixed === joined) {
-			return;
-		}
-
-		return {
-			node,
-			messageId: MESSAGE_ID_IMPROPERLY_INDENTED_TEMPLATE,
-			fix: fixer => fixed
-				.split(delimiter)
-				.map((replacement, index) => replaceTemplateElement(node.quasis[index], replacement, context, fixer)),
-		};
-	};
-
-	const shouldIndent = node => {
-		if (options.comments.length > 0) {
-			const previousToken = sourceCode.getTokenBefore(node, {includeComments: true});
-			if (previousToken?.type === 'Block' && options.comments.includes(previousToken.value.trim().toLowerCase())) {
-				return true;
-			}
-		}
-
-		if (isJestInlineSnapshot(node)) {
-			return true;
-		}
-
-		if (
-			options.tags.length > 0
-			&& isTaggedTemplateLiteral(node, options.tags)
-		) {
-			return true;
-		}
-
-		if (
-			options.functions.length > 0
-			&& node.parent.type === 'CallExpression'
-			&& node.parent.arguments.includes(node)
-			&& isNodeMatches(node.parent.callee, options.functions)
-		) {
-			return true;
-		}
-
-		if (options.selectors.length > 0) {
-			const ancestors = sourceCode.getAncestors(node).toReversed();
-			if (options.selectors.some(selector => esquery.matches(node, parseEsquerySelector(selector), ancestors))) {
-				return true;
-			}
-		}
-
-		return false;
-	};
-
-	return {
-		/** @param {import('@babel/core').types.TemplateLiteral} node */
-		TemplateLiteral(node) {
-			if (!shouldIndent(node)) {
-				return;
-			}
-
-			return getProblem(node);
-		},
-	};
-};
-
-/** @type {import('json-schema').JSONSchema7[]} */
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			indent: {
-				oneOf: [
-					{
-						type: 'string',
-						pattern: /^\s+$/.source,
-					},
-					{
-						type: 'integer',
-						minimum: 1,
-					},
-				],
-			},
-			tags: {
-				type: 'array',
-				uniqueItems: true,
-				items: {
-					type: 'string',
-				},
-			},
-			functions: {
-				type: 'array',
-				uniqueItems: true,
-				items: {
-					type: 'string',
-				},
-			},
-			selectors: {
-				type: 'array',
-				uniqueItems: true,
-				items: {
-					type: 'string',
-				},
-			},
-			comments: {
-				type: 'array',
-				uniqueItems: true,
-				items: {
-					type: 'string',
-				},
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Fix whitespace-insensitive template indentation.',
-			recommended: true,
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;