eslint-node-test 0.0.1

package/rules/utils/parentheses/get-parent-syntax-opening-parenthesis.js

@@ -0,0 +1,80 @@
+import {isOpeningParenToken as isOpeningParenthesisToken} from '@eslint-community/eslint-utils';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+@import {
+	OpeningParenToken as OpeningParenthesisToken,
+} from '@eslint-community/eslint-utils';
+*/
+
+/**
+Get the opening parenthesis of the parent node syntax if it exists.
+E.g., `if (a) {}` then the `(`.
+@param {ESTree.Node} node The AST node to check.
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {OpeningParenthesisToken | void} The left parenthesis of the parent node syntax
+*/
+function getParentSyntaxOpeningParenthesis(node, context) {
+	const {parent} = node;
+
+	switch (parent.type) {
+		case 'CallExpression':
+		case 'NewExpression': {
+			if (parent.arguments.length === 1 && parent.arguments[0] === node) {
+				return context.sourceCode.getTokenAfter(
+					parent.typeArguments ?? parent.callee,
+					isOpeningParenthesisToken,
+				);
+			}
+
+			return;
+		}
+
+		case 'DoWhileStatement': {
+			if (parent.test === node) {
+				return context.sourceCode.getTokenAfter(
+					parent.body,
+					isOpeningParenthesisToken,
+				);
+			}
+
+			return;
+		}
+
+		case 'IfStatement':
+		case 'WhileStatement': {
+			if (parent.test === node) {
+				return context.sourceCode.getFirstToken(parent, 1);
+			}
+
+			return;
+		}
+
+		case 'ImportExpression': {
+			if (parent.source === node) {
+				return context.sourceCode.getFirstToken(parent, 1);
+			}
+
+			return;
+		}
+
+		case 'SwitchStatement': {
+			if (parent.discriminant === node) {
+				return context.sourceCode.getFirstToken(parent, 1);
+			}
+
+			return;
+		}
+
+		case 'WithStatement': {
+			if (parent.object === node) {
+				return context.sourceCode.getFirstToken(parent, 1);
+			}
+		}
+
+		// No default
+	}
+}
+
+export default getParentSyntaxOpeningParenthesis;

package/rules/utils/parentheses/iterate-surrounding-parentheses.js

@@ -0,0 +1,82 @@
+// Based on https://github.com/eslint-community/eslint-utils/blob/1da21d4440028679f3c8d5841b85f9d97ca7f0f7/src/is-parenthesized.mjs#L1
+
+import {
+	isOpeningParenToken as isOpeningParenthesisToken,
+	isClosingParenToken as isClosingParenthesisToken,
+} from '@eslint-community/eslint-utils';
+import getParentSyntaxOpeningParenthesis from './get-parent-syntax-opening-parenthesis.js';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+@import {
+	OpeningParenToken as OpeningParenthesisToken,
+	ClosingParenToken as ClosingParenthesisToken,
+} from '@eslint-community/eslint-utils';
+*/
+
+/**
+@typedef {[OpeningParenthesisToken, ClosingParenthesisToken]} ParenthesisTokenPair
+*/
+
+/**
+Get surrounding parenthesis of the tokens or nodes.
+
+@param {[ESTree.Node | OpeningParenthesisToken, ESTree.Node | ClosingParenthesisToken]} param0
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns [ParenthesisTokenPair | void]
+*/
+function getSurroundingParentheses([head, tail], context) {
+	const tokenBefore = context.sourceCode.getTokenBefore(head);
+
+	if (!tokenBefore || !isOpeningParenthesisToken(tokenBefore)) {
+		return;
+	}
+
+	const tokenAfter = context.sourceCode.getTokenAfter(tail);
+
+	if (!tokenAfter || !isClosingParenthesisToken(tokenAfter)) {
+		return;
+	}
+
+	return [tokenBefore, tokenAfter];
+}
+
+const SYNTAX_OPENING_PARENTHESIS_INITIAL_VALUE = Symbol('SYNTAX_OPENING_PARENTHESIS_INITIAL_VALUE');
+
+/**
+Iterate surrounding parenthesis of the node.
+
+@param {ESTree.Node} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {IterableIterator<ParenthesisTokenPair>}
+*/
+function * iterateSurroundingParentheses(node, context) {
+	if (
+		!node
+		// `Program` can't be parenthesized
+		|| !node.parent
+		// `CatchClause.param` can't be parenthesized, example `try {} catch (error) {}`
+		|| (node.parent.type === 'CatchClause' && node.parent.param === node)
+	) {
+		return;
+	}
+
+	let syntaxOpeningParenthesis = SYNTAX_OPENING_PARENTHESIS_INITIAL_VALUE;
+	let parentheses = [node, node];
+	while ((parentheses = getSurroundingParentheses(parentheses, context))) {
+		const [openingParenthesisToken] = parentheses;
+
+		if (syntaxOpeningParenthesis === SYNTAX_OPENING_PARENTHESIS_INITIAL_VALUE) {
+			syntaxOpeningParenthesis = getParentSyntaxOpeningParenthesis(node, context);
+		}
+
+		if (openingParenthesisToken === syntaxOpeningParenthesis) {
+			break;
+		}
+
+		yield parentheses;
+	}
+}
+
+export default iterateSurroundingParentheses;

package/rules/utils/parentheses/parentheses.js

@@ -0,0 +1,69 @@
+import iterateSurroundingParentheses from './iterate-surrounding-parentheses.js';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+@import {
+	OpeningParenToken as OpeningParenthesisToken,
+	ClosingParenToken as ClosingParenthesisToken,
+} from '@eslint-community/eslint-utils';
+*/
+
+/** @typedef {WeakMap<ESTree.Node, (OpeningParenthesisToken | ClosingParenthesisToken)[]>} */
+const parenthesesCache = new WeakMap();
+
+/**
+Get surrounding parenthesis of the node.
+
+@param {ESTree.Node} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns [(OpeningParenthesisToken | ClosingParenthesisToken)[]]
+*/
+export function getParentheses(node, context) {
+	if (!node || !parenthesesCache.has(node)) {
+		const parenthesis = [];
+		for (const [openingParenthesisToken, closingParenthesisToken] of iterateSurroundingParentheses(node, context)) {
+			parenthesis.unshift(openingParenthesisToken);
+			parenthesis.push(closingParenthesisToken);
+		}
+
+		parenthesesCache.set(node, parenthesis);
+	}
+
+	return parenthesesCache.get(node);
+}
+
+/*
+Get the parenthesized range of the node.
+
+@param {ESTree.Node} node - The node to be checked.
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {number[]}
+*/
+export function getParenthesizedRange(node, context) {
+	const parentheses = getParentheses(node, context);
+	const [start] = context.sourceCode.getRange(parentheses[0] ?? node);
+	const [, end] = context.sourceCode.getRange(parentheses.at(-1) ?? node);
+	return [start, end];
+}
+
+/**
+Check whether a given node is parenthesized or not.
+
+@param {ESTree.Node} node The AST node to check.
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {boolean} `true` if the node is parenthesized.
+*/
+export function isParenthesized(node, context) {
+	if (parenthesesCache.has(node)) {
+		return parenthesesCache.get(node).length > 0;
+	}
+
+	const isNotParenthesized = iterateSurroundingParentheses(node, context).next().done;
+
+	if (isNotParenthesized) {
+		parenthesesCache.set(node, []);
+	}
+
+	return !isNotParenthesized;
+}

package/rules/utils/types.js

@@ -0,0 +1,5 @@
+const unknownTypeNames = new Set(['any', 'error', 'unknown']);
+
+const isUnknownType = type => unknownTypeNames.has(type.intrinsicName);
+
+export {isUnknownType};

package/rules/utils/unwrap-typescript-expression.js

@@ -0,0 +1,16 @@
+const typeScriptExpressionWrapperTypes = new Set([
+	'TSAsExpression',
+	'TSSatisfiesExpression',
+	'TSNonNullExpression',
+	'TSTypeAssertion',
+]);
+
+export const isTypeScriptExpressionWrapper = node => typeScriptExpressionWrapperTypes.has(node?.type);
+
+export default function unwrapTypeScriptExpression(node) {
+	while (isTypeScriptExpressionWrapper(node)) {
+		node = node.expression;
+	}
+
+	return node;
+}

package/rules/valid-describe-callback.js

@@ -0,0 +1,63 @@
+import {resolveImports, parseTestCall, getTestCallback} from './utils/node-test.js';
+
+const MESSAGE_ID_PARAMETER = 'valid-describe-callback/parameter';
+const MESSAGE_ID_RETURN = 'valid-describe-callback/return';
+
+const messages = {
+	[MESSAGE_ID_PARAMETER]: 'The `{{name}}` callback is called with no arguments. The test context is only passed to `test`/`it` callbacks.',
+	[MESSAGE_ID_RETURN]: 'The `{{name}}` callback should not return a value, `node:test` ignores it. Use a block body.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const imports = resolveImports(context);
+	if (!imports.isTestFile) {
+		return;
+	}
+
+	context.on('CallExpression', function * (node) {
+		const parsed = parseTestCall(node, imports);
+		if (parsed?.kind !== 'suite') {
+			return;
+		}
+
+		const callback = getTestCallback(node);
+		if (!callback) {
+			return;
+		}
+
+		if (callback.params.length > 0) {
+			yield {
+				node: callback.params[0],
+				messageId: MESSAGE_ID_PARAMETER,
+				data: {name: parsed.name},
+			};
+		}
+
+		// An arrow with an expression body implicitly returns a value.
+		if (callback.type === 'ArrowFunctionExpression' && callback.body.type !== 'BlockStatement') {
+			yield {
+				node: callback.body,
+				messageId: MESSAGE_ID_RETURN,
+				data: {name: parsed.name},
+			};
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce valid `describe` callbacks.',
+			recommended: 'unopinionated',
+		},
+		schema: [],
+		messages,
+		languages: ['js/js'],
+	},
+};
+
+export default config;