@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-instanceof-builtins.js

@@ -1,216 +0,0 @@
-import {
-	checkVueTemplate,
-	getParenthesizedRange,
-	getTokenStore,
-} from './utils/index.js';
-import {replaceNodeOrTokenAndSpacesBefore, fixSpaceAroundKeyword} from './fix/index.js';
-import builtinErrors from './shared/builtin-errors.js';
-import typedArray from './shared/typed-array.js';
-
-const isInstanceofToken = token => token.value === 'instanceof' && token.type === 'Keyword';
-
-const MESSAGE_ID = 'no-instanceof-builtins';
-const MESSAGE_ID_SWITCH_TO_TYPE_OF = 'switch-to-type-of';
-const messages = {
-	[MESSAGE_ID]: 'Avoid using `instanceof` for type checking as it can lead to unreliable results.',
-	[MESSAGE_ID_SWITCH_TO_TYPE_OF]: 'Switch to `typeof … === \'{{type}}\'`.',
-};
-
-const primitiveWrappers = new Set([
-	'String',
-	'Number',
-	'Boolean',
-	'BigInt',
-	'Symbol',
-]);
-
-const strictStrategyConstructors = [
-	// Error types
-	...builtinErrors,
-
-	// Collection types
-	'Map',
-	'Set',
-	'WeakMap',
-	'WeakRef',
-	'WeakSet',
-
-	// Arrays and Typed Arrays
-	'ArrayBuffer',
-	...typedArray,
-
-	// Data types
-	'Object',
-
-	// Regular Expressions
-	'RegExp',
-
-	// Async and functions
-	'Promise',
-	'Proxy',
-
-	// Other
-	'DataView',
-	'Date',
-	'SharedArrayBuffer',
-	'FinalizationRegistry',
-];
-
-const replaceWithFunctionCall = (node, context, functionName) => function * (fixer) {
-	const {left, right} = node;
-	const tokenStore = getTokenStore(context, node);
-	const instanceofToken = tokenStore.getTokenAfter(left, isInstanceofToken);
-
-	yield * fixSpaceAroundKeyword(fixer, node, context);
-
-	const range = getParenthesizedRange(left, {sourceCode: tokenStore});
-	yield fixer.insertTextBeforeRange(range, functionName + '(');
-	yield fixer.insertTextAfterRange(range, ')');
-
-	yield * replaceNodeOrTokenAndSpacesBefore(instanceofToken, '', fixer, context, tokenStore);
-	yield * replaceNodeOrTokenAndSpacesBefore(right, '', fixer, context, tokenStore);
-};
-
-const replaceWithTypeOfExpression = (node, context) => function * (fixer) {
-	const {left, right} = node;
-	const tokenStore = getTokenStore(context, node);
-	const instanceofToken = tokenStore.getTokenAfter(left, isInstanceofToken);
-	const {sourceCode} = context;
-
-	// Check if the node is in a Vue template expression
-	const vueExpressionContainer = sourceCode.getAncestors(node).findLast(ancestor => ancestor.type === 'VExpressionContainer');
-
-	// Get safe quote
-	const safeQuote = vueExpressionContainer ? (sourceCode.getText(vueExpressionContainer)[0] === '"' ? '\'' : '"') : '\'';
-
-	yield * fixSpaceAroundKeyword(fixer, node, context);
-
-	const leftRange = getParenthesizedRange(left, {sourceCode: tokenStore});
-	yield fixer.insertTextBeforeRange(leftRange, 'typeof ');
-
-	yield fixer.replaceText(instanceofToken, '===');
-
-	const rightRange = getParenthesizedRange(right, {sourceCode: tokenStore});
-
-	yield fixer.replaceTextRange(rightRange, safeQuote + sourceCode.getText(right).toLowerCase() + safeQuote);
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const {
-		useErrorIsError = false,
-		strategy = 'loose',
-		include = [],
-		exclude = [],
-	} = context.options[0] ?? {};
-
-	const forbiddenConstructors = new Set(
-		strategy === 'strict'
-			? [...strictStrategyConstructors, ...include]
-			: include,
-	);
-
-	return {
-		/** @param {import('estree').BinaryExpression} node */
-		BinaryExpression(node) {
-			const {right, operator} = node;
-
-			if (right.type !== 'Identifier' || operator !== 'instanceof' || exclude.includes(right.name)) {
-				return;
-			}
-
-			const constructorName = right.name;
-
-			/** @type {import('eslint').Rule.ReportDescriptor} */
-			const problem = {
-				node,
-				messageId: MESSAGE_ID,
-			};
-
-			if (
-				constructorName === 'Array'
-				|| (constructorName === 'Error' && useErrorIsError)
-			) {
-				const functionName = constructorName === 'Array' ? 'Array.isArray' : 'Error.isError';
-				problem.fix = replaceWithFunctionCall(node, context, functionName);
-				return problem;
-			}
-
-			if (constructorName === 'Function') {
-				problem.fix = replaceWithTypeOfExpression(node, context);
-				return problem;
-			}
-
-			if (primitiveWrappers.has(constructorName)) {
-				problem.suggest = [
-					{
-						messageId: MESSAGE_ID_SWITCH_TO_TYPE_OF,
-						data: {type: constructorName.toLowerCase()},
-						fix: replaceWithTypeOfExpression(node, context),
-					},
-				];
-				return problem;
-			}
-
-			if (!forbiddenConstructors.has(constructorName)) {
-				return;
-			}
-
-			return problem;
-		},
-	};
-};
-
-const schema = [
-	{
-		type: 'object',
-		properties: {
-			useErrorIsError: {
-				type: 'boolean',
-			},
-			strategy: {
-				enum: [
-					'loose',
-					'strict',
-				],
-			},
-			include: {
-				type: 'array',
-				items: {
-					type: 'string',
-				},
-			},
-			exclude: {
-				type: 'array',
-				items: {
-					type: 'string',
-				},
-			},
-		},
-		additionalProperties: false,
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create: checkVueTemplate(create),
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow `instanceof` with built-in objects',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{
-			useErrorIsError: false,
-			strategy: 'loose',
-			include: [],
-			exclude: [],
-		}],
-		hasSuggestions: true,
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-invalid-fetch-options.js

@@ -1,112 +0,0 @@
-import {getStaticValue} from '@eslint-community/eslint-utils';
-import {
-	isCallExpression,
-	isNewExpression,
-	isUndefined,
-	isNullLiteral,
-} from './ast/index.js';
-
-const MESSAGE_ID_ERROR = 'no-invalid-fetch-options';
-const messages = {
-	[MESSAGE_ID_ERROR]: '"body" is not allowed when method is "{{method}}".',
-};
-
-const isObjectPropertyWithName = (node, name) =>
-	node.type === 'Property'
-	&& !node.computed
-	&& node.key.type === 'Identifier'
-	&& node.key.name === name;
-
-function checkFetchOptions(context, node) {
-	if (node.type !== 'ObjectExpression') {
-		return;
-	}
-
-	const {properties} = node;
-
-	const bodyProperty = properties.findLast(property => isObjectPropertyWithName(property, 'body'));
-
-	if (!bodyProperty) {
-		return;
-	}
-
-	const bodyValue = bodyProperty.value;
-	if (isUndefined(bodyValue) || isNullLiteral(bodyValue)) {
-		return;
-	}
-
-	const methodProperty = properties.findLast(property => isObjectPropertyWithName(property, 'method'));
-	// If `method` is omitted but there is an `SpreadElement`, we just ignore the case
-	if (!methodProperty) {
-		if (properties.some(node => node.type === 'SpreadElement')) {
-			return;
-		}
-
-		return {
-			node: bodyProperty.key,
-			messageId: MESSAGE_ID_ERROR,
-			data: {method: 'GET'},
-		};
-	}
-
-	const methodValue = methodProperty.value;
-
-	const scope = context.sourceCode.getScope(methodValue);
-	let method = getStaticValue(methodValue, scope)?.value;
-
-	if (typeof method !== 'string') {
-		return;
-	}
-
-	method = method.toUpperCase();
-	if (method !== 'GET' && method !== 'HEAD') {
-		return;
-	}
-
-	return {
-		node: bodyProperty.key,
-		messageId: MESSAGE_ID_ERROR,
-		data: {method},
-	};
-}
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('CallExpression', callExpression => {
-		if (!isCallExpression(callExpression, {
-			name: 'fetch',
-			minimumArguments: 2,
-			optional: false,
-		})) {
-			return;
-		}
-
-		return checkFetchOptions(context, callExpression.arguments[1]);
-	});
-
-	context.on('NewExpression', newExpression => {
-		if (!isNewExpression(newExpression, {
-			name: 'Request',
-			minimumArguments: 2,
-		})) {
-			return;
-		}
-
-		return checkFetchOptions(context, newExpression.arguments[1]);
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow invalid options in `fetch()` and `new Request()`.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-invalid-remove-event-listener.js

@@ -1,61 +0,0 @@
-import {getFunctionHeadLocation} from '@eslint-community/eslint-utils';
-import {isMethodCall} from './ast/index.js';
-
-const MESSAGE_ID = 'no-invalid-remove-event-listener';
-const messages = {
-	[MESSAGE_ID]: 'The listener argument should be a function reference.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	CallExpression(callExpression) {
-		if (!(
-			isMethodCall(callExpression, {
-				method: 'removeEventListener',
-				minimumArguments: 2,
-				optionalCall: false,
-			})
-			&& callExpression.arguments[0].type !== 'SpreadElement'
-			&& (
-				callExpression.arguments[1].type === 'FunctionExpression'
-				|| callExpression.arguments[1].type === 'ArrowFunctionExpression'
-				|| isMethodCall(callExpression.arguments[1], {
-					method: 'bind',
-					optionalCall: false,
-					optionalMember: false,
-				})
-			)
-		)) {
-			return;
-		}
-
-		const [, listener] = callExpression.arguments;
-		if (['ArrowFunctionExpression', 'FunctionExpression'].includes(listener.type)) {
-			return {
-				node: listener,
-				loc: getFunctionHeadLocation(listener, context.sourceCode),
-				messageId: MESSAGE_ID,
-			};
-		}
-
-		return {
-			node: listener.callee.property,
-			messageId: MESSAGE_ID,
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Prevent calling `EventTarget#removeEventListener()` with the result of an expression.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-keyword-prefix.js

@@ -1,202 +0,0 @@
-import isShorthandPropertyAssignmentPatternLeft from './utils/is-shorthand-property-assignment-pattern-left.js';
-
-const MESSAGE_ID = 'noKeywordPrefix';
-const messages = {
-	[MESSAGE_ID]: 'Do not prefix identifiers with keyword `{{keyword}}`.',
-};
-
-const prepareOptions = ({
-	disallowedPrefixes,
-	checkProperties = true,
-	onlyCamelCase = true,
-} = {}) => ({
-	disallowedPrefixes: (disallowedPrefixes || [
-		'new',
-		'class',
-	]),
-	checkProperties,
-	onlyCamelCase,
-});
-
-function findKeywordPrefix(name, options) {
-	return options.disallowedPrefixes.find(keyword => {
-		const suffix = options.onlyCamelCase ? '[A-Z]' : '.';
-		const regex = new RegExp(`^${keyword}${suffix}`);
-		return name.match(regex);
-	});
-}
-
-function checkMemberExpression(report, node, options) {
-	const {name, parent} = node;
-	const keyword = findKeywordPrefix(name, options);
-	const effectiveParent = parent.type === 'MemberExpression' ? parent.parent : parent;
-
-	if (!options.checkProperties) {
-		return;
-	}
-
-	if (parent.object.type === 'Identifier' && parent.object.name === name && Boolean(keyword)) {
-		report(node, keyword);
-	} else if (
-		effectiveParent.type === 'AssignmentExpression'
-		&& Boolean(keyword)
-		&& (effectiveParent.right.type !== 'MemberExpression' || effectiveParent.left.type === 'MemberExpression')
-		&& effectiveParent.left.property.name === name
-	) {
-		report(node, keyword);
-	}
-}
-
-function checkObjectPattern(report, node, options) {
-	const {name, parent} = node;
-	const keyword = findKeywordPrefix(name, options);
-
-	/* c8 ignore next 3 */
-	if (parent.shorthand && parent.value.left && Boolean(keyword)) {
-		report(node, keyword);
-	}
-
-	const assignmentKeyEqualsValue = parent.key.name === parent.value.name;
-
-	if (Boolean(keyword) && parent.computed) {
-		report(node, keyword);
-	}
-
-	// Prevent checking right hand side of destructured object
-	if (parent.key === node && parent.value !== node) {
-		return true;
-	}
-
-	const valueIsInvalid = parent.value.name && Boolean(keyword);
-
-	// Ignore destructuring if the option is set, unless a new identifier is created
-	if (valueIsInvalid && !assignmentKeyEqualsValue) {
-		report(node, keyword);
-	}
-
-	return false;
-}
-
-// Core logic copied from:
-// https://github.com/eslint/eslint/blob/master/lib/rules/camelcase.js
-const create = context => {
-	const options = prepareOptions(context.options[0]);
-
-	// Contains reported nodes to avoid reporting twice on destructuring with shorthand notation
-	const reported = [];
-	const ALLOWED_PARENT_TYPES = new Set(['CallExpression', 'NewExpression']);
-
-	function report(node, keyword) {
-		if (!reported.includes(node)) {
-			reported.push(node);
-			context.report({
-				node,
-				messageId: MESSAGE_ID,
-				data: {
-					name: node.name,
-					keyword,
-				},
-			});
-		}
-	}
-
-	return {
-		Identifier(node) {
-			const {name, parent} = node;
-			const keyword = findKeywordPrefix(name, options);
-			const effectiveParent = parent.type === 'MemberExpression' ? parent.parent : parent;
-
-			if (parent.type === 'MemberExpression') {
-				checkMemberExpression(report, node, options);
-			} else if (
-				parent.type === 'Property'
-				|| parent.type === 'AssignmentPattern'
-			) {
-				if (parent.parent.type === 'ObjectPattern') {
-					const finished = checkObjectPattern(report, node, options);
-					if (finished) {
-						return;
-					}
-				}
-
-				if (
-					!options.checkProperties
-				) {
-					return;
-				}
-
-				// Don't check right hand side of AssignmentExpression to prevent duplicate warnings
-				if (
-					Boolean(keyword)
-					&& !ALLOWED_PARENT_TYPES.has(effectiveParent.type)
-					&& !(parent.right === node)
-					&& !isShorthandPropertyAssignmentPatternLeft(node)
-				) {
-					report(node, keyword);
-				}
-
-			// Check if it's an import specifier
-			} else if (
-				[
-					'ImportSpecifier',
-					'ImportNamespaceSpecifier',
-					'ImportDefaultSpecifier',
-				].includes(parent.type)
-			) {
-				// Report only if the local imported identifier is invalid
-				if (Boolean(keyword) && parent.local?.name === name) {
-					report(node, keyword);
-				}
-
-			// Report anything that is invalid that isn't a CallExpression
-			} else if (
-				Boolean(keyword)
-				&& !ALLOWED_PARENT_TYPES.has(effectiveParent.type)
-			) {
-				report(node, keyword);
-			}
-		},
-	};
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			disallowedPrefixes: {
-				type: 'array',
-				items: [
-					{
-						type: 'string',
-					},
-				],
-				minItems: 0,
-				uniqueItems: true,
-			},
-			checkProperties: {
-				type: 'boolean',
-			},
-			onlyCamelCase: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow identifiers starting with `new` or `class`.',
-			recommended: false,
-		},
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;