@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/custom-error-definition.js

@@ -1,218 +0,0 @@
-import {upperFirst} from './utils/index.js';
-
-const MESSAGE_ID_INVALID_EXPORT = 'invalidExport';
-const messages = {
-	[MESSAGE_ID_INVALID_EXPORT]: 'Exported error name should match error class',
-};
-
-const nameRegexp = /^(?:[A-Z][\da-z]*)*Error$/;
-
-const getClassName = name => upperFirst(name).replace(/(?:error|)$/i, 'Error');
-
-const getConstructorMethod = className => `
-	constructor() {
-		super();
-		this.name = '${className}';
-	}
-`;
-
-const hasValidSuperClass = node => {
-	if (!node.superClass) {
-		return false;
-	}
-
-	let {name, type, property} = node.superClass;
-
-	if (type === 'MemberExpression') {
-		({name} = property);
-	}
-
-	return nameRegexp.test(name);
-};
-
-const isSuperExpression = node =>
-	node.type === 'ExpressionStatement'
-	&& node.expression.type === 'CallExpression'
-	&& node.expression.callee.type === 'Super';
-
-const isAssignmentExpression = (node, name) => {
-	if (
-		node.type !== 'ExpressionStatement'
-		|| node.expression.type !== 'AssignmentExpression'
-	) {
-		return false;
-	}
-
-	const lhs = node.expression.left;
-
-	if (!lhs.object || lhs.object.type !== 'ThisExpression') {
-		return false;
-	}
-
-	return lhs.property.name === name;
-};
-
-const isPropertyDefinition = (node, name) =>
-	node.type === 'PropertyDefinition'
-	&& !node.computed
-	&& node.key.type === 'Identifier'
-	&& node.key.name === name;
-
-function * customErrorDefinition(context, node) {
-	if (!hasValidSuperClass(node)) {
-		return;
-	}
-
-	if (node.id === null) {
-		return;
-	}
-
-	const {name} = node.id;
-	const className = getClassName(name);
-
-	if (name !== className) {
-		yield {
-			node: node.id,
-			message: `Invalid class name, use \`${className}\`.`,
-		};
-	}
-
-	const {sourceCode} = context;
-	const {body} = node.body;
-	const range = sourceCode.getRange(node.body);
-	const constructor = body.find(x => x.kind === 'constructor');
-
-	if (!constructor) {
-		yield {
-			node,
-			message: 'Add a constructor to your error.',
-			fix: fixer => fixer.insertTextAfterRange([
-				range[0],
-				range[0] + 1,
-			], getConstructorMethod(name)),
-		};
-		return;
-	}
-
-	const constructorBodyNode = constructor.value.body;
-
-	// Verify the constructor has a body (TypeScript)
-	if (!constructorBodyNode) {
-		return;
-	}
-
-	const constructorBody = constructorBodyNode.body;
-
-	const superExpression = constructorBody.find(body => isSuperExpression(body));
-	const messageExpressionIndex = constructorBody.findIndex(x => isAssignmentExpression(x, 'message'));
-
-	if (!superExpression) {
-		yield {
-			node: constructorBodyNode,
-			message: 'Missing call to `super()` in constructor.',
-		};
-	} else if (messageExpressionIndex !== -1) {
-		const expression = constructorBody[messageExpressionIndex];
-
-		yield {
-			node: superExpression,
-			message: 'Pass the error message to `super()` instead of setting `this.message`.',
-			* fix(fixer) {
-				if (superExpression.expression.arguments.length === 0) {
-					const rhs = expression.expression.right;
-					const [start] = sourceCode.getRange(superExpression);
-					yield fixer.insertTextAfterRange([start, start + 6], rhs.raw || rhs.name);
-				}
-
-				const start = messageExpressionIndex === 0
-					? sourceCode.getRange(constructorBodyNode)[0]
-					: sourceCode.getRange(constructorBody[messageExpressionIndex - 1])[1];
-				const [, end] = sourceCode.getRange(expression);
-				yield fixer.removeRange([start, end]);
-			},
-		};
-	}
-
-	const nameExpression = constructorBody.find(x => isAssignmentExpression(x, 'name'));
-	if (!nameExpression) {
-		const nameProperty = body.find(node => isPropertyDefinition(node, 'name'));
-
-		if (!nameProperty?.value || nameProperty.value.value !== name) {
-			yield {
-				node: nameProperty?.value ?? constructorBodyNode,
-				message: `The \`name\` property should be set to \`${name}\`.`,
-			};
-		}
-	} else if (nameExpression.expression.right.value !== name) {
-		yield {
-			node: nameExpression?.expression.right ?? constructorBodyNode,
-			message: `The \`name\` property should be set to \`${name}\`.`,
-		};
-	}
-}
-
-const customErrorExport = (context, node) => {
-	const exportsName = node.left.property.name;
-
-	const maybeError = node.right;
-
-	if (maybeError.type !== 'ClassExpression') {
-		return;
-	}
-
-	if (!hasValidSuperClass(maybeError)) {
-		return;
-	}
-
-	if (!maybeError.id) {
-		return;
-	}
-
-	// Assume rule has already fixed the error name
-	const errorName = maybeError.id.name;
-
-	if (exportsName === errorName) {
-		return;
-	}
-
-	return {
-		node: node.left.property,
-		messageId: MESSAGE_ID_INVALID_EXPORT,
-		fix: fixer => fixer.replaceText(node.left.property, errorName),
-	};
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on('ClassDeclaration', node => customErrorDefinition(context, node));
-	context.on('AssignmentExpression', node => {
-		if (node.right.type === 'ClassExpression') {
-			return customErrorDefinition(context, node.right);
-		}
-	});
-	context.on('AssignmentExpression', node => {
-		if (
-			node.left.type === 'MemberExpression'
-			&& node.left.object.type === 'Identifier'
-			&& node.left.object.name === 'exports'
-		) {
-			return customErrorExport(context, node);
-		}
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Enforce correct `Error` subclassing.',
-			recommended: false,
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/empty-brace-spaces.js

@@ -1,62 +0,0 @@
-import {isOpeningBraceToken} from '@eslint-community/eslint-utils';
-
-const MESSAGE_ID = 'empty-brace-spaces';
-const messages = {
-	[MESSAGE_ID]: 'Do not add spaces between braces.',
-};
-
-const getProblem = (node, context) => {
-	const {sourceCode} = context;
-	const openingBrace = sourceCode.getFirstToken(node, {filter: isOpeningBraceToken});
-	const closingBrace = sourceCode.getLastToken(node);
-	const [, start] = sourceCode.getRange(openingBrace);
-	const [end] = sourceCode.getRange(closingBrace);
-	const textBetween = sourceCode.text.slice(start, end);
-
-	if (!/^\s+$/.test(textBetween)) {
-		return;
-	}
-
-	return {
-		loc: {
-			start: sourceCode.getLoc(openingBrace).end,
-			end: sourceCode.getLoc(closingBrace).start,
-		},
-		messageId: MESSAGE_ID,
-		fix: fixer => fixer.removeRange([start, end]),
-	};
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on([
-		'BlockStatement',
-		'ClassBody',
-		'StaticBlock',
-		'ObjectExpression',
-	], node => {
-		const children = node.type === 'ObjectExpression' ? node.properties : node.body;
-
-		if (children.length > 0) {
-			return;
-		}
-
-		return getProblem(node, context);
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'layout',
-		docs: {
-			description: 'Enforce no spaces between braces.',
-			recommended: true,
-		},
-		fixable: 'whitespace',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/error-message.js

@@ -1,98 +0,0 @@
-import {getStaticValue} from '@eslint-community/eslint-utils';
-import {isCallOrNewExpression} from './ast/index.js';
-import builtinErrors from './shared/builtin-errors.js';
-
-const MESSAGE_ID_MISSING_MESSAGE = 'missing-message';
-const MESSAGE_ID_EMPTY_MESSAGE = 'message-is-empty-string';
-const MESSAGE_ID_NOT_STRING = 'message-is-not-a-string';
-const messages = {
-	[MESSAGE_ID_MISSING_MESSAGE]: 'Pass a message to the `{{constructorName}}` constructor.',
-	[MESSAGE_ID_EMPTY_MESSAGE]: 'Error message should not be an empty string.',
-	[MESSAGE_ID_NOT_STRING]: 'Error message should be a string.',
-};
-
-const messageArgumentIndexes = new Map([
-	['AggregateError', 1],
-	['SuppressedError', 2],
-]);
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	context.on(['CallExpression', 'NewExpression'], expression => {
-		if (!(
-			isCallOrNewExpression(expression, {
-				names: builtinErrors,
-				optional: false,
-			})
-			&& context.sourceCode.isGlobalReference(expression.callee)
-		)) {
-			return;
-		}
-
-		const constructorName = expression.callee.name;
-		const messageArgumentIndex = messageArgumentIndexes.has(constructorName)
-			? messageArgumentIndexes.get(constructorName)
-			: 0;
-		const callArguments = expression.arguments;
-
-		// If message is `SpreadElement` or there is `SpreadElement` before message
-		if (callArguments.some((node, index) => index <= messageArgumentIndex && node.type === 'SpreadElement')) {
-			return;
-		}
-
-		const node = callArguments[messageArgumentIndex];
-		if (!node) {
-			return {
-				node: expression,
-				messageId: MESSAGE_ID_MISSING_MESSAGE,
-				data: {constructorName},
-			};
-		}
-
-		// These types can't be string, and `getStaticValue` may don't know the value
-		// Add more types, if issue reported
-		if (node.type === 'ArrayExpression' || node.type === 'ObjectExpression') {
-			return {
-				node,
-				messageId: MESSAGE_ID_NOT_STRING,
-			};
-		}
-
-		const staticResult = getStaticValue(node, context.sourceCode.getScope(node));
-
-		// We don't know the value of `message`
-		if (!staticResult) {
-			return;
-		}
-
-		const {value} = staticResult;
-		if (typeof value !== 'string') {
-			return {
-				node,
-				messageId: MESSAGE_ID_NOT_STRING,
-			};
-		}
-
-		if (value === '') {
-			return {
-				node,
-				messageId: MESSAGE_ID_EMPTY_MESSAGE,
-			};
-		}
-	});
-};
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Enforce passing a `message` value when creating a built-in error.',
-			recommended: 'unopinionated',
-		},
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,86 +0,0 @@
-import {replaceTemplateElement} from './fix/index.js';
-import {isRegexLiteral, isStringLiteral, isTaggedTemplateLiteral} from './ast/index.js';
-
-const MESSAGE_ID_UPPERCASE = 'escape-uppercase';
-const MESSAGE_ID_LOWERCASE = 'escape-lowercase';
-const messages = {
-	[MESSAGE_ID_UPPERCASE]: 'Use uppercase characters for the value of the escape sequence.',
-	[MESSAGE_ID_LOWERCASE]: 'Use lowercase characters for the value of the escape sequence.',
-};
-
-const escapeCase = /(?<=(?:^|[^\\])(?:\\\\)*\\)(?<data>x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|u{[\dA-Fa-f]+})/g;
-const escapePatternCase = /(?<=(?:^|[^\\])(?:\\\\)*\\)(?<data>x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|u{[\dA-Fa-f]+}|c[A-Za-z])/g;
-const getProblem = ({node, original, regex = escapeCase, lowercase, fix}) => {
-	const fixed = original.replace(regex, data => data[0] + data.slice(1)[lowercase ? 'toLowerCase' : 'toUpperCase']());
-
-	if (fixed !== original) {
-		return {
-			node,
-			messageId: lowercase ? MESSAGE_ID_LOWERCASE : MESSAGE_ID_UPPERCASE,
-			fix: fixer => fix ? fix(fixer, fixed) : fixer.replaceText(node, fixed),
-		};
-	}
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const lowercase = context.options[0] === 'lowercase';
-
-	context.on('Literal', node => {
-		if (isStringLiteral(node)) {
-			return getProblem({
-				node,
-				original: node.raw,
-				lowercase,
-			});
-		}
-	});
-
-	context.on('Literal', node => {
-		if (isRegexLiteral(node)) {
-			return getProblem({
-				node,
-				original: node.raw,
-				regex: escapePatternCase,
-				lowercase,
-			});
-		}
-	});
-
-	context.on('TemplateElement', node => {
-		if (isTaggedTemplateLiteral(node.parent, ['String.raw'])) {
-			return;
-		}
-
-		return getProblem({
-			node,
-			original: node.value.raw,
-			lowercase,
-			fix: (fixer, fixed) => replaceTemplateElement(node, fixed, context, fixer),
-		});
-	});
-};
-
-const schema = [
-	{
-		enum: ['uppercase', 'lowercase'],
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Require escape sequences to use uppercase or lowercase values.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: ['uppercase'],
-		messages,
-	},
-};
-
-export default config;