@alexlit/lint-kit 176.0.1 → 177.0.0

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

@@ -1,110 +0,0 @@
-import {addParenthesizesToReturnOrThrowExpression, removeSpacesAfter} from './fix/index.js';
-import {isParenthesized} from './utils/parentheses.js';
-import needsSemicolon from './utils/needs-semicolon.js';
-import isOnSameLine from './utils/is-on-same-line.js';
-
-const MESSAGE_ID = 'no-unnecessary-await';
-const messages = {
-	[MESSAGE_ID]: 'Do not `await` non-promise value.',
-};
-
-function notPromise(node) {
-	switch (node.type) {
-		case 'ArrayExpression':
-		case 'ArrowFunctionExpression':
-		case 'AwaitExpression':
-		case 'BinaryExpression':
-		case 'ClassExpression':
-		case 'FunctionExpression':
-		case 'JSXElement':
-		case 'JSXFragment':
-		case 'Literal':
-		case 'TemplateLiteral':
-		case 'UnaryExpression':
-		case 'UpdateExpression': {
-			return true;
-		}
-
-		case 'SequenceExpression': {
-			return notPromise(node.expressions.at(-1));
-		}
-
-		// No default
-	}
-
-	return false;
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	AwaitExpression(node) {
-		if (
-			// F#-style pipeline operator, `Promise.resolve() |> await`
-			!node.argument
-			|| !notPromise(node.argument)
-		) {
-			return;
-		}
-
-		const {sourceCode} = context;
-		const awaitToken = sourceCode.getFirstToken(node);
-		const problem = {
-			node,
-			loc: sourceCode.getLoc(awaitToken),
-			messageId: MESSAGE_ID,
-		};
-
-		const valueNode = node.argument;
-		if (
-			// Removing `await` may change them to a declaration, if there is no `id` will cause SyntaxError
-			valueNode.type === 'FunctionExpression'
-			|| valueNode.type === 'ClassExpression'
-			// `+await +1` -> `++1`
-			|| (
-				node.parent.type === 'UnaryExpression'
-				&& valueNode.type === 'UnaryExpression'
-				&& node.parent.operator === valueNode.operator
-			)
-		) {
-			return problem;
-		}
-
-		return Object.assign(problem, {
-			/** @param {import('eslint').Rule.RuleFixer} fixer */
-			* fix(fixer) {
-				if (
-					!isOnSameLine(awaitToken, valueNode, context)
-					&& !isParenthesized(node, sourceCode)
-				) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, node.parent, context);
-				}
-
-				yield fixer.remove(awaitToken);
-				yield removeSpacesAfter(awaitToken, context, fixer);
-
-				const nextToken = sourceCode.getTokenAfter(awaitToken);
-				const tokenBefore = sourceCode.getTokenBefore(awaitToken);
-				if (needsSemicolon(tokenBefore, context, nextToken.value)) {
-					yield fixer.insertTextBefore(nextToken, ';');
-				}
-			},
-		});
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow awaiting non-promise values.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,174 +0,0 @@
-import path from 'node:path';
-import coreJsCompat from 'core-js-compat';
-import {camelCase} from 'change-case';
-import isStaticRequire from './ast/is-static-require.js';
-import {readPackageJson} from './shared/package-json.js';
-
-const {data: compatData, entries: coreJsEntries} = coreJsCompat;
-
-const MESSAGE_ID_POLYFILL = 'unnecessaryPolyfill';
-const MESSAGE_ID_CORE_JS = 'unnecessaryCoreJsModule';
-const messages = {
-	[MESSAGE_ID_POLYFILL]: 'Use built-in instead.',
-	[MESSAGE_ID_CORE_JS]:
-		'All polyfilled features imported from `{{coreJsModule}}` are available as built-ins. Use the built-ins instead.',
-};
-
-const additionalPolyfillPatterns = {
-	'es.promise.finally': '|(p-finally)',
-	'es.object.set-prototype-of': '|(setprototypeof)',
-	'es.string.code-point-at': '|(code-point-at)',
-};
-
-const prefixes = '(mdn-polyfills/|polyfill-)';
-const suffixes = '(-polyfill)';
-const delimiter = String.raw`(\.|-|\.prototype\.|/)?`;
-
-const polyfills = Object.keys(compatData).map(feature => {
-	let [ecmaVersion, constructorName, methodName = ''] = feature.split('.');
-
-	if (ecmaVersion === 'es') {
-		ecmaVersion = String.raw`(es\d*)`;
-	}
-
-	constructorName = `(${constructorName}|${camelCase(constructorName)})`;
-	methodName &&= `(${methodName}|${camelCase(methodName)})`;
-
-	const methodOrConstructor = methodName || constructorName;
-
-	const patterns = [
-		`^((${prefixes}?(`,
-		methodName && `(${ecmaVersion}${delimiter}${constructorName}${delimiter}${methodName})|`, // Ex: es6-array-copy-within
-		methodName && `(${constructorName}${delimiter}${methodName})|`, // Ex: array-copy-within
-		`(${ecmaVersion}${delimiter}${constructorName}))`, // Ex: es6-array
-		`${suffixes}?)|`,
-		`(${prefixes}${methodOrConstructor}|${methodOrConstructor}${suffixes})`, // Ex: polyfill-copy-within / polyfill-promise
-		`${additionalPolyfillPatterns[feature] || ''})$`,
-	];
-
-	return {
-		feature,
-		pattern: new RegExp(patterns.join(''), 'i'),
-	};
-});
-
-function getTargets(options, dirname) {
-	if (options?.targets) {
-		return options.targets;
-	}
-
-	const packageJsonResult = readPackageJson(dirname);
-
-	if (!packageJsonResult) {
-		return;
-	}
-
-	const {browserslist, engines} = packageJsonResult.packageJson;
-	return browserslist ?? engines;
-}
-
-function create(context) {
-	const targets = getTargets(context.options[0], path.dirname(context.filename));
-	if (!targets) {
-		return {};
-	}
-
-	let unavailableFeatures;
-	try {
-		unavailableFeatures = coreJsCompat({targets}).list;
-	} catch {
-		// This can happen if the targets are invalid or use unsupported syntax like `{node:'*'}`.
-		return {};
-	}
-
-	const checkFeatures = features => !features.every(feature => unavailableFeatures.includes(feature));
-
-	return {
-		Literal(node) {
-			if (
-				!(
-					(['ImportDeclaration', 'ImportExpression'].includes(node.parent.type) && node.parent.source === node)
-					|| (isStaticRequire(node.parent) && node.parent.arguments[0] === node)
-				)
-			) {
-				return;
-			}
-
-			const importedModule = node.value;
-			if (typeof importedModule !== 'string' || ['.', '/'].includes(importedModule[0])) {
-				return;
-			}
-
-			const coreJsModuleFeatures = coreJsEntries[importedModule.replace('core-js-pure', 'core-js')];
-
-			if (coreJsModuleFeatures) {
-				if (coreJsModuleFeatures.length > 1) {
-					if (checkFeatures(coreJsModuleFeatures)) {
-						return {
-							node,
-							messageId: MESSAGE_ID_CORE_JS,
-							data: {
-								coreJsModule: importedModule,
-							},
-						};
-					}
-				} else if (!unavailableFeatures.includes(coreJsModuleFeatures[0])) {
-					return {node, messageId: MESSAGE_ID_POLYFILL};
-				}
-
-				return;
-			}
-
-			const polyfill = polyfills.find(({pattern}) => pattern.test(importedModule));
-			if (polyfill) {
-				const [, namespace, method = ''] = polyfill.feature.split('.');
-				const features = coreJsEntries[`core-js/full/${namespace}${method && '/'}${method}`];
-
-				if (features && checkFeatures(features)) {
-					return {node, messageId: MESSAGE_ID_POLYFILL};
-				}
-			}
-		},
-	};
-}
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		required: ['targets'],
-		properties: {
-			targets: {
-				oneOf: [
-					{
-						type: 'string',
-					},
-					{
-						type: 'array',
-					},
-					{
-						type: 'object',
-					},
-				],
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce the use of built-in methods instead of unnecessary polyfills.',
-			recommended: 'unopinionated',
-		},
-		schema,
-		// eslint-disable-next-line eslint-plugin/require-meta-default-options
-		defaultOptions: [],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-unnecessary-slice-end.js

@@ -1,22 +0,0 @@
-import {listen} from './shared/no-unnecessary-length-or-infinity-rule.js';
-
-const MESSAGE_ID = 'no-unnecessary-slice-end';
-const messages = {
-	[MESSAGE_ID]: 'Passing `{{description}}` as the `end` argument is unnecessary.',
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create: context => listen(context, {methods: ['slice'], messageId: MESSAGE_ID}),
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow using `.length` or `Infinity` as the `end` argument of `{Array,String,TypedArray}#slice()`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,85 +0,0 @@
-import {isParenthesized} from '@eslint-community/eslint-utils';
-import shouldAddParenthesesToMemberExpressionObject from './utils/should-add-parentheses-to-member-expression-object.js';
-import {fixSpaceAroundKeyword} from './fix/index.js';
-
-const MESSAGE_ID = 'no-unreadable-array-destructuring';
-const messages = {
-	[MESSAGE_ID]: 'Array destructuring may not contain consecutive ignored values.',
-};
-
-const isCommaFollowedWithComma = (element, index, array) =>
-	element === null && array[index + 1] === null;
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-
-	return {
-		ArrayPattern(node) {
-			const {elements, parent} = node;
-
-			if (
-				elements.length < 3
-				|| !elements.some((element, index, elements) => isCommaFollowedWithComma(element, index, elements))) {
-				return;
-			}
-
-			const problem = {
-				node,
-				messageId: MESSAGE_ID,
-			};
-
-			const nonNullElements = elements.filter(node => node !== null);
-			if (
-				parent.type === 'VariableDeclarator'
-				&& parent.id === node
-				&& parent.init !== null
-				&& nonNullElements.length === 1
-			) {
-				const [element] = nonNullElements;
-
-				if (element.type !== 'AssignmentPattern') {
-					problem.fix = function * (fixer) {
-						const index = elements.indexOf(element);
-						const isSlice = element.type === 'RestElement';
-						const variable = isSlice ? element.argument : element;
-
-						yield fixer.replaceText(node, sourceCode.getText(variable));
-
-						const code = isSlice ? `.slice(${index})` : `[${index}]`;
-						const array = parent.init;
-						if (
-							!isParenthesized(array, sourceCode)
-							&& shouldAddParenthesesToMemberExpressionObject(array, context)
-						) {
-							yield fixer.insertTextBefore(array, '(');
-							yield fixer.insertTextAfter(parent, `)${code}`);
-						} else {
-							yield fixer.insertTextAfter(parent, code);
-						}
-
-						yield fixSpaceAroundKeyword(fixer, node, context);
-					};
-				}
-			}
-
-			return problem;
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow unreadable array destructuring.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,43 +0,0 @@
-import {isParenthesized, getParenthesizedRange, toLocation} from './utils/index.js';
-
-const MESSAGE_ID_ERROR = 'no-unreadable-iife';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'IIFE with parenthesized arrow function body is considered unreadable.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(callExpression) {
-		const {sourceCode} = context;
-
-		if (
-			callExpression.callee.type !== 'ArrowFunctionExpression'
-			|| callExpression.callee.body.type === 'BlockStatement'
-			|| !isParenthesized(callExpression.callee.body, sourceCode)
-		) {
-			return;
-		}
-
-		return {
-			node: callExpression,
-			loc: toLocation(getParenthesizedRange(callExpression.callee.body, context), context),
-			messageId: MESSAGE_ID_ERROR,
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow unreadable IIFEs.',
-			recommended: 'unopinionated',
-		},
-		hasSuggestions: false,
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,240 +0,0 @@
-import getScopes from './utils/get-scopes.js';
-
-const MESSAGE_ID = 'no-unused-properties';
-const messages = {
-	[MESSAGE_ID]: 'Property `{{name}}` is defined but never used.',
-};
-
-const getDeclaratorOrPropertyValue = declaratorOrProperty =>
-	declaratorOrProperty.init
-	|| declaratorOrProperty.value;
-
-const isMemberExpressionCall = memberExpression =>
-	memberExpression.parent.type === 'CallExpression'
-	&& memberExpression.parent.callee === memberExpression;
-
-const isMemberExpressionAssignment = memberExpression =>
-	memberExpression.parent.type === 'AssignmentExpression';
-
-const isMemberExpressionComputedBeyondPrediction = memberExpression =>
-	memberExpression.computed
-	&& memberExpression.property.type !== 'Literal';
-
-const specialProtoPropertyKey = {
-	type: 'Identifier',
-	name: '__proto__',
-};
-
-const propertyKeysEqual = (keyA, keyB) => {
-	if (keyA.type === 'Identifier') {
-		if (keyB.type === 'Identifier') {
-			return keyA.name === keyB.name;
-		}
-
-		if (keyB.type === 'Literal') {
-			return keyA.name === keyB.value;
-		}
-	}
-
-	if (keyA.type === 'Literal') {
-		if (keyB.type === 'Identifier') {
-			return keyA.value === keyB.name;
-		}
-
-		if (keyB.type === 'Literal') {
-			return keyA.value === keyB.value;
-		}
-	}
-
-	return false;
-};
-
-const objectPatternMatchesObjectExprPropertyKey = (pattern, key) =>
-	pattern.properties.some(property => {
-		if (property.type === 'RestElement') {
-			return true;
-		}
-
-		return propertyKeysEqual(property.key, key);
-	});
-
-const isLeafDeclaratorOrProperty = declaratorOrProperty => {
-	const value = getDeclaratorOrPropertyValue(declaratorOrProperty);
-
-	if (!value) {
-		return true;
-	}
-
-	if (value.type !== 'ObjectExpression') {
-		return true;
-	}
-
-	return false;
-};
-
-const isUnusedVariable = variable => {
-	const hasReadReference = variable.references.some(reference => reference.isRead());
-	return !hasReadReference;
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {sourceCode} = context;
-	const getPropertyDisplayName = property => {
-		if (property.key.type === 'Identifier') {
-			return property.key.name;
-		}
-
-		if (property.key.type === 'Literal') {
-			return property.key.value;
-		}
-
-		return sourceCode.getText(property.key);
-	};
-
-	const checkProperty = (property, references, path) => {
-		if (references.length === 0) {
-			context.report({
-				node: property,
-				messageId: MESSAGE_ID,
-				data: {
-					name: getPropertyDisplayName(property),
-				},
-			});
-			return;
-		}
-
-		checkObject(property, references, path);
-	};
-
-	const checkProperties = (objectExpression, references, path = []) => {
-		for (const property of objectExpression.properties) {
-			const {key} = property;
-
-			if (!key) {
-				continue;
-			}
-
-			if (propertyKeysEqual(key, specialProtoPropertyKey)) {
-				continue;
-			}
-
-			const nextPath = [...path, key];
-
-			const nextReferences = references
-				.map(reference => {
-					const {parent} = reference.identifier;
-
-					if (reference.init) {
-						if (
-							parent.type === 'VariableDeclarator'
-							&& parent.parent.type === 'VariableDeclaration'
-							&& parent.parent.parent.type === 'ExportNamedDeclaration'
-						) {
-							return {identifier: parent};
-						}
-
-						return;
-					}
-
-					if (parent.type === 'MemberExpression') {
-						if (
-							isMemberExpressionAssignment(parent)
-							|| isMemberExpressionCall(parent)
-							|| isMemberExpressionComputedBeyondPrediction(parent)
-							|| propertyKeysEqual(parent.property, key)
-						) {
-							return {identifier: parent};
-						}
-
-						return;
-					}
-
-					if (
-						parent.type === 'VariableDeclarator'
-						&& parent.id.type === 'ObjectPattern'
-					) {
-						if (objectPatternMatchesObjectExprPropertyKey(parent.id, key)) {
-							return {identifier: parent};
-						}
-
-						return;
-					}
-
-					if (
-						parent.type === 'AssignmentExpression'
-						&& parent.left.type === 'ObjectPattern'
-					) {
-						if (objectPatternMatchesObjectExprPropertyKey(parent.left, key)) {
-							return {identifier: parent};
-						}
-
-						return;
-					}
-
-					return reference;
-				})
-				.filter(Boolean);
-
-			checkProperty(property, nextReferences, nextPath);
-		}
-	};
-
-	const checkObject = (declaratorOrProperty, references, path) => {
-		if (isLeafDeclaratorOrProperty(declaratorOrProperty)) {
-			return;
-		}
-
-		const value = getDeclaratorOrPropertyValue(declaratorOrProperty);
-
-		checkProperties(value, references, path);
-	};
-
-	const checkVariable = variable => {
-		if (variable.defs.length !== 1) {
-			return;
-		}
-
-		if (isUnusedVariable(variable)) {
-			return;
-		}
-
-		const [definition] = variable.defs;
-
-		checkObject(definition.node, variable.references);
-	};
-
-	const checkVariables = scope => {
-		for (const variable of scope.variables) {
-			checkVariable(variable);
-		}
-	};
-
-	return {
-		'Program:exit'(program) {
-			const scopes = getScopes(sourceCode.getScope(program));
-			for (const scope of scopes) {
-				if (scope.type === 'global') {
-					continue;
-				}
-
-				checkVariables(scope);
-			}
-		},
-	};
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow unused object properties.',
-			recommended: false,
-		},
-		messages,
-	},
-};
-
-export default config;