@alexlit/lint-kit 174.0.0 → 176.0.0

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

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

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

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

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