@alexlit/lint-kit 174.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/relative-url-style.js

@@ -0,0 +1,171 @@
+import {getStaticValue} from '@eslint-community/eslint-utils';
+import {isNewExpression, isStringLiteral} from './ast/index.js';
+
+const MESSAGE_ID_NEVER = 'never';
+const MESSAGE_ID_ALWAYS = 'always';
+const MESSAGE_ID_REMOVE = 'remove';
+const messages = {
+	[MESSAGE_ID_NEVER]: 'Remove the `./` prefix from the relative URL.',
+	[MESSAGE_ID_ALWAYS]: 'Add a `./` prefix to the relative URL.',
+	[MESSAGE_ID_REMOVE]: 'Remove leading `./`.',
+};
+
+const DOT_SLASH = './';
+const TEST_URL_BASES = [
+	'https://example.com/a/b/',
+	'https://example.com/a/b.html',
+];
+const isSafeToAddDotSlashToUrl = (url, base) => {
+	try {
+		return new URL(url, base).href === new URL(DOT_SLASH + url, base).href;
+	} catch {}
+
+	return false;
+};
+
+const isSafeToAddDotSlash = (url, bases = TEST_URL_BASES) => bases.every(base => isSafeToAddDotSlashToUrl(url, base));
+const isSafeToRemoveDotSlash = (url, bases = TEST_URL_BASES) => bases.every(base => isSafeToAddDotSlashToUrl(url.slice(DOT_SLASH.length), base));
+
+function canAddDotSlash(node, sourceCode) {
+	const url = node.value;
+	if (url.startsWith(DOT_SLASH) || url.startsWith('.') || url.startsWith('/')) {
+		return false;
+	}
+
+	const baseNode = node.parent.arguments[1];
+	const staticValueResult = getStaticValue(baseNode, sourceCode.getScope(node));
+
+	if (
+		typeof staticValueResult?.value === 'string'
+		&& isSafeToAddDotSlash(url, [staticValueResult.value])
+	) {
+		return true;
+	}
+
+	return isSafeToAddDotSlash(url);
+}
+
+function canRemoveDotSlash(node, sourceCode) {
+	const rawValue = node.raw.slice(1, -1);
+	if (!rawValue.startsWith(DOT_SLASH)) {
+		return false;
+	}
+
+	const baseNode = node.parent.arguments[1];
+	const staticValueResult = getStaticValue(baseNode, sourceCode.getScope(node));
+
+	if (
+		typeof staticValueResult?.value === 'string'
+		&& isSafeToRemoveDotSlash(node.value, [staticValueResult.value])
+	) {
+		return true;
+	}
+
+	return isSafeToRemoveDotSlash(node.value);
+}
+
+function addDotSlash(node, sourceCode) {
+	if (!canAddDotSlash(node, sourceCode)) {
+		return;
+	}
+
+	const insertPosition = sourceCode.getRange(node)[0] + 1; // After quote
+	return fixer => fixer.insertTextAfterRange([insertPosition, insertPosition], DOT_SLASH);
+}
+
+function removeDotSlash(node, sourceCode) {
+	if (!canRemoveDotSlash(node, sourceCode)) {
+		return;
+	}
+
+	const start = sourceCode.getRange(node)[0] + 1; // After quote
+	return fixer => fixer.removeRange([start, start + 2]);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const style = context.options[0] || 'never';
+
+	const listeners = {};
+
+	// TemplateLiteral are not always safe to remove `./`, but if it's starts with `./` we'll report
+	if (style === 'never') {
+		listeners.TemplateLiteral = function (node) {
+			if (!(
+				isNewExpression(node.parent, {name: 'URL', argumentsLength: 2})
+				&& node.parent.arguments[0] === node
+			)) {
+				return;
+			}
+
+			const firstPart = node.quasis[0];
+			if (!firstPart.value.raw.startsWith(DOT_SLASH)) {
+				return;
+			}
+
+			return {
+				node,
+				messageId: style,
+				suggest: [
+					{
+						messageId: MESSAGE_ID_REMOVE,
+						fix(fixer) {
+							const start = context.sourceCode.getRange(firstPart)[0] + 1;
+							return fixer.removeRange([start, start + DOT_SLASH.length]);
+						},
+					},
+				],
+			};
+		};
+	}
+
+	listeners.Literal = function (node) {
+		if (!(
+			isStringLiteral(node)
+			&& isNewExpression(node.parent, {name: 'URL', argumentsLength: 2})
+			&& node.parent.arguments[0] === node
+		)) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const fix = (style === 'never' ? removeDotSlash : addDotSlash)(node, sourceCode);
+
+		if (!fix) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: style,
+			fix,
+		};
+	};
+
+	return listeners;
+};
+
+const schema = [
+	{
+		enum: ['never', 'always'],
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent relative URL style.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema,
+		defaultOptions: ['never'],
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/require-array-join-separator.js

@@ -0,0 +1,65 @@
+import {appendArgument} from './fix/index.js';
+import {isMethodCall} from './ast/index.js';
+import {isArrayPrototypeProperty} from './utils/index.js';
+
+const MESSAGE_ID = 'require-array-join-separator';
+const messages = {
+	[MESSAGE_ID]: 'Missing the separator argument.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		if (!(
+			// `foo.join()`
+			isMethodCall(node, {
+				method: 'join',
+				argumentsLength: 0,
+				optionalCall: false,
+			})
+			// `[].join.call(foo)` and `Array.prototype.join.call(foo)`
+			|| (
+				isMethodCall(node, {
+					method: 'call',
+					argumentsLength: 1,
+					optionalCall: false,
+					optionalMember: false,
+				})
+				&& isArrayPrototypeProperty(node.callee.object, {
+					property: 'join',
+				})
+			)
+		)) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const [penultimateToken, lastToken] = sourceCode.getLastTokens(node, 2);
+		const isPrototypeMethod = node.arguments.length === 1;
+		return {
+			loc: {
+				start: sourceCode.getLoc(penultimateToken)[isPrototypeMethod ? 'end' : 'start'],
+				end: sourceCode.getLoc(lastToken).end,
+			},
+			messageId: MESSAGE_ID,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => appendArgument(fixer, node, '\',\'', context),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce using the separator argument with `Array#join()`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/require-module-attributes.js

@@ -0,0 +1,120 @@
+import {isCommaToken} from '@eslint-community/eslint-utils';
+import {removeObjectProperty} from './fix/index.js';
+import {getParentheses} from './utils/index.js';
+
+const MESSAGE_ID = 'require-module-attributes';
+const messages = {
+	[MESSAGE_ID]: '{{type}} with empty attribute list is not allowed.',
+};
+
+const isWithToken = token => token?.type === 'Keyword' && token.value === 'with';
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	context.on(['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'], declaration => {
+		const {source, attributes} = declaration;
+
+		if (!source || (Array.isArray(attributes) && attributes.length > 0)) {
+			return;
+		}
+
+		const withToken = sourceCode.getTokenAfter(source);
+
+		if (!isWithToken(withToken)) {
+			return;
+		}
+
+		// `WithStatement` is not possible in modules, so we don't need worry it's not attributes
+
+		const openingBraceToken = sourceCode.getTokenAfter(withToken);
+		const closingBraceToken = sourceCode.getTokenAfter(openingBraceToken);
+
+		return {
+			node: declaration,
+			loc: {
+				start: sourceCode.getLoc(openingBraceToken).start,
+				end: sourceCode.getLoc(closingBraceToken).end,
+			},
+			messageId: MESSAGE_ID,
+			data: {
+				type: declaration.type === 'ImportDeclaration' ? 'import statement' : 'export statement',
+			},
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => [withToken, closingBraceToken, openingBraceToken].map(token => fixer.remove(token)),
+		};
+	});
+
+	context.on('ImportExpression', importExpression => {
+		const {options: optionsNode} = importExpression;
+
+		if (optionsNode?.type !== 'ObjectExpression') {
+			return;
+		}
+
+		const emptyWithProperty = optionsNode.properties.find(
+			property =>
+				property.type === 'Property'
+				&& !property.method
+				&& !property.shorthand
+				&& !property.computed
+				&& property.kind === 'init'
+				&& (
+					(
+						property.key.type === 'Identifier'
+						&& property.key.name === 'with'
+					)
+					|| (
+						property.key.type === 'Literal'
+						&& property.key.value === 'with'
+					)
+				)
+				&& property.value.type === 'ObjectExpression'
+				&& property.value.properties.length === 0,
+		);
+
+		const nodeToRemove = optionsNode.properties.length === 0 || (emptyWithProperty && optionsNode.properties.length === 1)
+			? optionsNode
+			: emptyWithProperty;
+
+		if (!nodeToRemove) {
+			return;
+		}
+
+		const isProperty = nodeToRemove.type === 'Property';
+
+		return {
+			node: emptyWithProperty?.value ?? nodeToRemove,
+			messageId: MESSAGE_ID,
+			data: {
+				type: 'import expression',
+			},
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => isProperty
+				? removeObjectProperty(fixer, nodeToRemove, context)
+				: [
+					// Comma token before
+					sourceCode.getTokenBefore(nodeToRemove, isCommaToken),
+					...sourceCode.getTokens(nodeToRemove),
+					...getParentheses(nodeToRemove, context),
+				].map(token => fixer.remove(token)),
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Require non-empty module attributes for imports and exports',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/require-module-specifiers.js

@@ -0,0 +1,158 @@
+import {isClosingBraceToken} from '@eslint-community/eslint-utils';
+
+const MESSAGE_ID_ERROR = 'error';
+const MESSAGE_ID_SUGGESTION_REMOVE_DECLARATION = 'suggestion/remove-declaration';
+const MESSAGE_ID_SUGGESTION_TO_SIDE_EFFECT_IMPORT = 'suggestion/to-side-effect-import';
+const messages = {
+	[MESSAGE_ID_ERROR]: '{{type}} statement without specifiers is not allowed.',
+	[MESSAGE_ID_SUGGESTION_REMOVE_DECLARATION]: 'Remove this {{type}} statement.',
+	[MESSAGE_ID_SUGGESTION_TO_SIDE_EFFECT_IMPORT]: 'Switch to side effect import.',
+};
+
+const isFromToken = token => token.type === 'Identifier' && token.value === 'from';
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	context.on('ImportDeclaration', importDeclaration => {
+		const {specifiers} = importDeclaration;
+
+		if (specifiers.some(node => node.type === 'ImportSpecifier' || node.type === 'ImportNamespaceSpecifier')) {
+			return;
+		}
+
+		const {source, importKind} = importDeclaration;
+		const fromToken = sourceCode.getTokenBefore(source);
+		if (!isFromToken(fromToken)) {
+			return;
+		}
+
+		const closingBraceToken = sourceCode.getTokenBefore(fromToken);
+		if (!isClosingBraceToken(closingBraceToken)) {
+			return;
+		}
+
+		const openingBraceToken = sourceCode.getTokenBefore(closingBraceToken);
+
+		const problem = {
+			node: importDeclaration,
+			loc: {
+				start: sourceCode.getLoc(openingBraceToken).start,
+				end: sourceCode.getLoc(closingBraceToken).end,
+			},
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				type: 'import',
+			},
+		};
+
+		// If there is a `ImportDefaultSpecifier`, it has to be the first.
+		const importDefaultSpecifier = specifiers.length === 1 ? specifiers[0] : undefined;
+		if (importKind === 'type' && !importDefaultSpecifier) {
+			problem.fix = fixer => fixer.remove(importDeclaration);
+			return problem;
+		}
+
+		if (importDefaultSpecifier) {
+			problem.fix = function * (fixer) {
+				yield fixer.remove(closingBraceToken);
+				yield fixer.remove(openingBraceToken);
+
+				const commaToken = sourceCode.getTokenBefore(openingBraceToken);
+				yield fixer.remove(commaToken);
+
+				if (sourceCode.getRange(closingBraceToken)[1] === sourceCode.getRange(fromToken)[0]) {
+					yield fixer.insertTextBefore(fromToken, ' ');
+				}
+			};
+
+			return problem;
+		}
+
+		problem.suggest = [
+			{
+				messageId: MESSAGE_ID_SUGGESTION_REMOVE_DECLARATION,
+				fix: fixer => fixer.remove(importDeclaration),
+			},
+			{
+				messageId: MESSAGE_ID_SUGGESTION_TO_SIDE_EFFECT_IMPORT,
+				* fix(fixer) {
+					yield fixer.remove(openingBraceToken);
+					yield fixer.remove(closingBraceToken);
+					yield fixer.remove(fromToken);
+				},
+			},
+		];
+
+		return problem;
+	});
+
+	context.on('ExportNamedDeclaration', exportDeclaration => {
+		const {specifiers, declaration} = exportDeclaration;
+
+		if (declaration || specifiers.length > 0) {
+			return;
+		}
+
+		const {source, exportKind} = exportDeclaration;
+		const fromToken = source ? sourceCode.getTokenBefore(source) : undefined;
+		const closingBraceToken = fromToken
+			? sourceCode.getTokenBefore(fromToken)
+			: sourceCode.getLastToken(exportDeclaration, isClosingBraceToken);
+		const openingBraceToken = sourceCode.getTokenBefore(closingBraceToken);
+
+		const problem = {
+			node: exportDeclaration,
+			loc: {
+				start: sourceCode.getLoc(openingBraceToken).start,
+				end: sourceCode.getLoc(closingBraceToken).end,
+			},
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				type: 'export',
+			},
+		};
+
+		if (!source || exportKind === 'type') {
+			problem.fix = fixer => fixer.remove(exportDeclaration);
+			return problem;
+		}
+
+		problem.suggest = [
+			{
+				messageId: MESSAGE_ID_SUGGESTION_REMOVE_DECLARATION,
+				fix: fixer => fixer.remove(exportDeclaration),
+			},
+			{
+				messageId: MESSAGE_ID_SUGGESTION_TO_SIDE_EFFECT_IMPORT,
+				* fix(fixer) {
+					const exportToken = sourceCode.getFirstToken(exportDeclaration);
+					yield fixer.replaceText(exportToken, 'import');
+					yield fixer.remove(openingBraceToken);
+					yield fixer.remove(closingBraceToken);
+					yield fixer.remove(fromToken);
+				},
+			},
+		];
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Require non-empty specifier list in import and export statements.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/require-number-to-fixed-digits-argument.js

@@ -0,0 +1,55 @@
+import {appendArgument} from './fix/index.js';
+import {isMethodCall} from './ast/index.js';
+
+const MESSAGE_ID = 'require-number-to-fixed-digits-argument';
+const messages = {
+	[MESSAGE_ID]: 'Missing the digits argument.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		if (
+			!isMethodCall(node, {
+				method: 'toFixed',
+				argumentsLength: 0,
+				optionalCall: false,
+			})
+			|| node.callee.object.type === 'NewExpression'
+		) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const [
+			openingParenthesis,
+			closingParenthesis,
+		] = sourceCode.getLastTokens(node, 2);
+
+		return {
+			loc: {
+				start: sourceCode.getLoc(openingParenthesis).start,
+				end: sourceCode.getLoc(closingParenthesis).end,
+			},
+			messageId: MESSAGE_ID,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => appendArgument(fixer, node, '0', context),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce using the digits argument with `Number#toFixed()`.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/require-post-message-target-origin.js

@@ -0,0 +1,74 @@
+import {isMethodCall} from './ast/index.js';
+import {appendArgument} from './fix/index.js';
+
+const ERROR = 'error';
+const SUGGESTION = 'suggestion';
+const messages = {
+	[ERROR]: 'Missing the `targetOrigin` argument.',
+	[SUGGESTION]: 'Use `{{code}}`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function create(context) {
+	const {sourceCode} = context;
+	return {
+		CallExpression(node) {
+			if (!isMethodCall(node, {
+				method: 'postMessage',
+				argumentsLength: 1,
+				optionalCall: false,
+			})) {
+				return;
+			}
+
+			const [penultimateToken, lastToken] = sourceCode.getLastTokens(node, 2);
+			const replacements = [];
+			const target = node.callee.object;
+			if (target.type === 'Identifier') {
+				const {name} = target;
+
+				replacements.push(`${name}.location.origin`);
+
+				if (name !== 'self' && name !== 'window' && name !== 'globalThis') {
+					replacements.push('self.location.origin');
+				}
+			} else {
+				replacements.push('self.location.origin');
+			}
+
+			replacements.push('\'*\'');
+
+			return {
+				loc: {
+					start: sourceCode.getLoc(penultimateToken).end,
+					end: sourceCode.getLoc(lastToken).end,
+				},
+				messageId: ERROR,
+				suggest: replacements.map(code => ({
+					messageId: SUGGESTION,
+					data: {code},
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					fix: fixer => appendArgument(fixer, node, code, context),
+				})),
+			};
+		},
+	};
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce using the `targetOrigin` argument with `window.postMessage()`.',
+			// Turned off because we can't distinguish `window.postMessage` and `{Worker,MessagePort,Client,BroadcastChannel}#postMessage()`
+			// See #1396
+			recommended: false,
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/get-documentation-url.js

@@ -0,0 +1,9 @@
+import path from 'node:path';
+import packageJson from '../../package.json' with {type: 'json'};
+
+const repoUrl = 'https://github.com/sindresorhus/eslint-plugin-unicorn';
+
+export default function getDocumentationUrl(filename) {
+	const ruleName = path.basename(filename, '.js');
+	return `${repoUrl}/blob/v${packageJson.version}/docs/rules/${ruleName}.md`;
+}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/index.js

@@ -0,0 +1,9 @@
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornCreate} from './to-eslint-create.js';
+@import {UnicornRule} from './to-eslint-rule.js';
+@import {UnicornContext} from './unicorn-context.js';
+@import {TSESTree as Estree} from '@typescript-eslint/types';
+*/
+
+export {default as createRules} from './to-eslint-rules.js';