@alexlit/lint-kit 174.0.0 → 176.0.0

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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,174 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,240 @@
+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;