lint-rules-alvin 1.0.5 → 1.1.0

package/eslint/configs/astro.js

@@ -1,9 +1,9 @@
 import eslintPluginAstro from 'eslint-plugin-astro';
 
 /**
- * The `ESLint` Astro config.
+ * The ESLint Astro config. Extends `configs['flat/base']` and configures all rules.
  *
- * Extends `eslint-plugin-astro`'s `flat/base` config.
+ * @type {import('eslint').Linter.Config}
  */
 export const astro = [
 	...eslintPluginAstro.configs['flat/base'],

package/eslint/configs/base.js

@@ -1,9 +1,14 @@
 import path from 'node:path';
 import { includeIgnoreFile } from '@eslint/compat';
+import eslintJs from '@eslint/js';
 import { globalIgnores } from 'eslint/config';
+import globals from 'globals';
 
 /**
- * The `ESLint` base config. Includes base rules, ignore files and directives.
+ * The ESLint base config. Includes base rules, ignore files and directives,
+ * and the recommended eslintJs rules.
+ *
+ * @type {import('eslint').Linter.Config}
  */
 export const base = [
 	includeIgnoreFile(
@@ -15,5 +20,18 @@ export const base = [
 	globalIgnores([
 		'eslint.config.js',
 		'eslint.config.ts'
-	])
+	]),
+	{
+		name: 'base/env',
+		languageOptions: {
+			ecmaVersion: 2020,
+			sourceType: 'module',
+			globals: {
+				...globals.browser,
+				...globals.nodeBuiltin,
+				...globals.serviceworker
+			}
+		}
+	},
+	eslintJs.configs.recommended
 ];

package/eslint/configs/custom.js

@@ -3,9 +3,14 @@ import { unnamedImportsLastRule } from '../custom_rules/unnamed-imports-last.js'
 import { jsxMultilinePropNewlineRule } from '../custom_rules/jsx-multiline-prop-newline.js';
 import { jsxNoSingleObjectCurlyNewlineRule } from '../custom_rules/jsx-no-single-object-curly-newline.js';
 import { maxChainPerLineRule } from '../custom_rules/max-chain-per-line.js';
-import { chainFirstOnNewlineRule } from '../custom_rules/chain-first-on-newline.js';
 import { multilineParenNewlineRule } from '../custom_rules/multiline-paren-newline.js';
+import { multilineArrayAccessorNewlineRule } from '../custom_rules/multiline-array-accessor-newline.js';
 
+/**
+ * Provides a config that creates a plugin and configures custom rules.
+ *
+ * @type {import('eslint').Linter.Config}
+ */
 export const custom = {
 	plugins: {
 		custom: {
@@ -15,8 +20,8 @@ export const custom = {
 				'jsx-multiline-prop-newline': jsxMultilinePropNewlineRule,
 				'jsx-no-single-object-curly-newline': jsxNoSingleObjectCurlyNewlineRule,
 				'max-chain-per-line': maxChainPerLineRule,
-				'chain-first-on-newline': chainFirstOnNewlineRule,
-				'multiline-paren-newline': multilineParenNewlineRule
+				'multiline-paren-newline': multilineParenNewlineRule,
+				'multiline-array-accessor-newline': multilineArrayAccessorNewlineRule
 			}
 		}
 	},
@@ -30,16 +35,15 @@ export const custom = {
 		'custom/jsx-no-single-object-curly-newline': 'error',
 		'custom/max-chain-per-line': [
 			'error',
-			{ maxChain: 2 }
-		],
-		'custom/chain-first-on-newline': [
-			'error',
-			'require'
+			{
+				maxChain: 2,
+				enforceSingleLine: true
+			}
 		],
 		'custom/multiline-paren-newline': [
 			'error',
 			{ singleArgument: true }
-		]
+		],
+		'custom/multiline-array-accessor-newline': 'error'
 	}
 };
-

package/eslint/configs/importX.js

@@ -1,7 +1,9 @@
 import { importX as eslintPluginImportX } from 'eslint-plugin-import-x';
 
 /**
- * The `ESLint` import config.
+ * The ESLint import config. Configures all rules.
+ *
+ * @type {import('eslint').Linter.Config}
  */
 export const importX = {
 	name: 'eslint-plugin-import-x',

package/eslint/configs/importXTs.js

@@ -2,9 +2,11 @@ import { importX as eslintPluginImportX } from 'eslint-plugin-import-x';
 import { importX } from './index.js';
 
 /**
- * The `ESLint` import config with a TS resolver.
+ * The ESLint import config with a TS resolver.
+ * Extends `../importX` and `flatConfigs.typescript` config.
+ *
+ * @type {import('eslint').Linter.Config}
  *
- * Extends `eslint-plugin-import-x`'s `typescript` flat config.
  */
 export const importXTs = {
 	...importX,

package/eslint/configs/json.js

@@ -1,20 +1,23 @@
 import eslintPluginJsonc from 'eslint-plugin-jsonc';
 
 /**
- * The `ESLint` JSON config. Supports JSON, JSONc an JSON5.
+ * The ESLint JSON config. Extends `flat/recommended-with-json`,
+ * `...with-jsonc` and `...with-json5` for the corresponding file types.
+ *
+ * @type {import('eslint').Linter.Config}
  */
 export const json = [
-	{ // eslint-plugin-json
+	{
 		name: 'eslint-plugin-json',
 		files: [ '**/*.{json}' ],
 		...eslintPluginJsonc.configs['flat/recommended-with-json']
 	},
-	{ // eslint-plugin-jsonc
+	{
 		name: 'eslint-plugin-jsonc',
 		files: [ '**/*.{jsonc}' ],
 		...eslintPluginJsonc.configs['flat/recommended-with-jsonc']
 	},
-	{ // eslint-plugin-json5
+	{
 		name: 'eslint-plugin-json5',
 		files: [ '**/*.{json5}' ],
 		...eslintPluginJsonc.configs['flat/recommended-with-json5']

package/eslint/configs/markdown.js

@@ -1,7 +1,10 @@
 import eslintPluginMarkdown from 'eslint-plugin-markdown';
 
 /**
- * The `ESLint` markdown config.
+ * The ESLint markdown config. Extends `configs.recommended` only for `md` files.
+ *
+ * @type {import('eslint').Linter.Config}
+ *
  */
 export const markdown = {
 	name: 'eslint-plugin-markdown',

package/eslint/configs/reactHooks.js

@@ -1,7 +1,15 @@
 import eslintPluginReactHooks from 'eslint-plugin-react-hooks';
 
+/**
+ * The ESLint `react-hooks` config. Extends `configs.flat.recommended` only for `jsx` and `tsx` files.
+ *
+ * @type {import('eslint').Linter.Config}
+ */
 export const reactHooks = {
 	name: 'eslint-plugin-react-hooks',
 	files: [ '**/*.{jsx,tsx}' ],
-	...eslintPluginReactHooks.configs.flat.recommended
+	...eslintPluginReactHooks
+		.configs
+		.flat
+		.recommended
 };

package/eslint/configs/stylistic.js

@@ -1,5 +1,11 @@
+// eslint-disable-next-line import-x/no-deprecated, import-x/namespace, import-x/default
 import eslintPluginStylistic from '@stylistic/eslint-plugin';
 
+/**
+ * The ESLint `stylistic` config. Extends `configs.recommended` and overrides all rules.
+ *
+ * @type {import('eslint').Linter.Config}
+ */
 export const stylistic = {
 	name: 'eslint-plugin-stylistic',
 	...eslintPluginStylistic.configs.recommended,
@@ -309,6 +315,7 @@ export const stylistic = {
 			'all',
 			{
 				ignoreJSX: 'multi-line',
+				nestedBinaryExpressions: false,
 				ignoredNodes: [
 
 					// Arrow function ternaries

package/eslint/configs/typescript.js

@@ -1,6 +1,11 @@
-import eslintTs from 'typescript-eslint';
+import eslintTs from '@typescript-eslint/eslint-plugin';
+import eslintTsParser from '@typescript-eslint/parser';
 
 /**
+ * The ESLint `typescript` config. Extends `configs.base`,
+ * enables `languageOptions.parserOptions.projectService` and configures all rules,
+ * only for `ts`, `tsx`, `mts` and `cts` files.
+ *
  * @type {import('eslint').Linter.Config}
  */
 export const typescript = {
@@ -11,8 +16,12 @@ export const typescript = {
 		'**/*.mts',
 		'**/*.cts'
 	],
-	...eslintTs.configs.base,
-	languageOptions: { parserOptions: { projectService: true } },
+	...eslintTs.configs['flat/base'],
+	languageOptions: {
+		parser: eslintTsParser,
+		parserOptions: { projectService: true },
+		sourceType: 'module'
+	},
 	rules: {
 		'@typescript-eslint/array-type': [
 			'error',
@@ -458,7 +467,6 @@ export const typescript = {
 			'always'
 		],
 		'@typescript-eslint/sort-type-constituents': 'off', // Deprecated in favor of sort-intersection-types, etc.
-		'@typescript-eslint/strict-boolean-expressions': 'off',
 		'@typescript-eslint/strict-boolean-expressions': [
 			'error',
 			{
@@ -498,7 +506,10 @@ export const typescript = {
 				ignoreOverloadsWithDifferentJSDoc: true
 			}
 		],
-		'@typescript-eslint/use-unknown-in-catch-callback-variable': 'off'
+		'@typescript-eslint/use-unknown-in-catch-callback-variable': 'off',
+
+		// Other base ESLint overrides
+		'no-undef': 'off'
 
 	}
 };

package/eslint/custom_rules/jsx-multiline-prop-newline.js

@@ -20,7 +20,13 @@ export const jsxMultilinePropNewlineRule = {
 
 		function isMultiline(node) {
 
-			return node && node.loc && node.loc.start.line < node.loc.end.line;
+			return node && node.loc && node
+				.loc
+				.start
+				.line < node
+				.loc
+				.end
+				.line;
 
 		}
 
@@ -63,7 +69,16 @@ export const jsxMultilinePropNewlineRule = {
 				const firstProp = node.attributes[0];
 
 				// Check if the tag name and the first prop are on the same line.
-				if (node.name.loc.end.line === firstProp.loc.start.line) {
+				if (
+					node
+						.name
+						.loc
+						.end
+						.line === firstProp
+						.loc
+						.start
+						.line
+				) {
 
 					context.report({
 						node: firstProp,
@@ -72,8 +87,12 @@ export const jsxMultilinePropNewlineRule = {
 
 							// Get indentation of the line with the opening tag.
 							const line = sourceCode
-								.getLines()
-								[node.loc.start.line - 1];
+								.getLines()[
+									node
+										.loc
+										.start
+										.line - 1
+								];
 							const baseIndentMatch = line.match(/^\s*/);
 							const baseIndent = baseIndentMatch
 								? baseIndentMatch[0]

package/eslint/custom_rules/jsx-no-single-object-curly-newline.js

@@ -31,7 +31,15 @@ export const jsxNoSingleObjectCurlyNewlineRule = {
 				}
 
 				// If the expression itself isn't multiline, there are no newlines to collapse.
-				if (expression.loc.start.line === expression.loc.end.line) {
+				if (
+					expression
+						.loc
+						.start
+						.line === expression
+						.loc
+						.end
+						.line
+				) {
 
 					return;
 
@@ -42,8 +50,20 @@ export const jsxNoSingleObjectCurlyNewlineRule = {
 				const firstTokenInExpression = sourceCode.getFirstToken(expression);
 				const lastTokenInExpression = sourceCode.getLastToken(expression);
 
-				const hasNewlineBefore = openingBrace.loc.end.line < firstTokenInExpression.loc.start.line;
-				const hasNewlineAfter = lastTokenInExpression.loc.end.line < closingBrace.loc.start.line;
+				const hasNewlineBefore = openingBrace
+					.loc
+					.end
+					.line < firstTokenInExpression
+					.loc
+					.start
+					.line;
+				const hasNewlineAfter = lastTokenInExpression
+					.loc
+					.end
+					.line < closingBrace
+					.loc
+					.start
+					.line;
 
 				if (hasNewlineBefore || hasNewlineAfter) {
 

package/eslint/custom_rules/max-chain-per-line.js

@@ -5,8 +5,7 @@ export const maxChainPerLineRule = {
 	meta: {
 		type: 'layout',
 		docs: {
-
-			description: 'Require a newline after each item in a chain if it\'s too long and contains a call.',
+			description: 'Require a newline after each item in a chain if it\'s too long.',
 			category: 'Stylistic Issues'
 		},
 		fixable: 'whitespace',
@@ -16,102 +15,200 @@ export const maxChainPerLineRule = {
 				properties: {
 					maxChain: {
 						type: 'integer',
-						minimum: 1
+						minimum: 1,
+						default: 2
+					},
+					enforceSingleLine: {
+						type: 'boolean',
+						default: false
 					}
 				},
 				additionalProperties: false
 			}
 		],
-		messages: { expectedNewline: 'This call chain is too long and should be broken into multiple lines.' }
+		messages: {
+			expectedNewline: 'This call chain is too long and should be broken into multiple lines.',
+			noNewline: 'Unexpected newline in chain.'
+		}
 	},
 	create(context) {
 
-		const options = context.options[0] || {};
-		const maxChain = options.maxChain || 2;
-		const sourceCode = context.sourceCode;
+		const {
+			maxChain = 2, enforceSingleLine = false
+		} = context.options[0] || {};
+		const sourceCode = context.getSourceCode();
+		const processedChains = new Set();
+
+		/**
+		 * Traverses the AST from a given node upwards to find the outermost
+		 * node of a continuous chain.
+		 */
+		function getOutermostChainNode(node) {
+
+			let outermostNode = node;
+			while (outermostNode.parent) {
 
-		function isChainable(node) {
+				const parent = outermostNode.parent;
+				if (
+					(parent.type === 'MemberExpression' && parent.object === outermostNode)
+					|| (parent.type === 'CallExpression' && parent.callee === outermostNode)
+				) {
 
-			if (!node)
-				return false;
-			return node.type === 'MemberExpression' || node.type === 'CallExpression';
+					outermostNode = parent;
+
+				} else {
+
+					break;
+
+				}
+
+			}
+			return outermostNode;
 
 		}
 
-		function check(node) {
+		/**
+		 * Deconstructs a chain into an array of its "links".
+		 * A "link" is defined as a non-computed property access (`.prop`).
+		 * Any subsequent CallExpressions or computed accesses (`[key]`) are
+		 * considered part of that same link.
+		 * @param {import('estree').Node} node The outermost node of the chain.
+		 * @returns {import('estree').MemberExpression[]} An array of MemberExpression nodes that start each link.
+		 */
+		function getChainLinks(node) {
 
-			const members = [];
-			let callCount = 0;
-			let current = node;
+			const links = [];
+			let currentNode = node;
 
-			while (isChainable(current)) {
+			while (currentNode.type === 'MemberExpression' || currentNode.type === 'CallExpression') {
 
-				if (current.type === 'CallExpression') {
+				if (currentNode.type === 'CallExpression') {
+
+					// A call is part of the preceding link, so we just traverse through it.
+					currentNode = currentNode.callee;
+					continue;
+
+				}
 
-					callCount++;
-					current = current.callee;
+				// We have a MemberExpression.
+				if (currentNode.computed) {
 
-				} else { // MemberExpression
+					// A computed property (`[key]`) is part of the preceding link.
+					currentNode = currentNode.object;
 
-					members.unshift(current);
-					current = current.object;
+				} else {
+
+					// A non-computed property (`.prop`) is a new link.
+					links.unshift(currentNode);
+					currentNode = currentNode.object;
 
 				}
 
 			}
-			const root = current;
-			const totalChainLength = members.length + 1;
+			return links;
 
-			let iter = node;
-			while(isChainable(iter)) {
+		}
 
-				if (iter.type === 'CallExpression') {
+		function checkChain(node) {
 
-					callCount++;
+			const outermostNode = getOutermostChainNode(node);
 
-				}
-				iter = iter.type === 'CallExpression'
-					? iter.callee
-					: iter.object;
+			if (processedChains.has(outermostNode)) {
+
+				return;
 
 			}
+			processedChains.add(outermostNode);
+
+			const links = getChainLinks(outermostNode);
+			const chainCount = links.length;
 
-			const isMultiline = root.loc.start.line !== node.loc.end.line;
+			if (chainCount <= 1) {
 
-			if (callCount > 0) {
+				return;
 
-				if (!isMultiline && totalChainLength > maxChain) {
+			}
 
-					context.report({
-						node: node,
-						messageId: 'expectedNewline',
-						fix(fixer) {
+			const baseIndent = sourceCode.lines[
+				outermostNode
+					.loc
+					.start
+					.line - 1
+			].match(/^\s*/)[0];
+
+			// --- Mode 1: Enforce newlines if chain is too long ---
+			if (chainCount > maxChain) {
+
+				for (const linkNode of links) {
+
+					// Find the dot separator for this link.
+					const separatorToken = sourceCode.getTokenBefore(
+						linkNode.property,
+						{ filter: (token) => token.value === '.' || token.value === '?.' }
+					);
+
+					// We only care about the dot's position relative to the start of its own link.
+					const previousNode = linkNode.object;
+					if (
+						separatorToken
+							.loc
+							.start
+							.line === previousNode
+							.loc
+							.end
+							.line
+					) {
+
+						context.report({
+							node: linkNode.property,
+							loc: separatorToken.loc,
+							messageId: 'expectedNewline',
+							fix: (fixer) => fixer.insertTextBefore(
+								separatorToken,
+								`\n${baseIndent}`
+							)
+						});
 
-							const fixes = [];
-							members.forEach(
-								(memberNode) => {
+					}
 
-									const propertyNode = memberNode.property;
-									const dotToken = sourceCode.getTokenBefore(propertyNode);
-									const rootLine = sourceCode
-										.getLines()
-										[root.loc.start.line - 1];
-									const indent = (rootLine
-										.match(/^\s*/)
-										[0] || '') + '  ';
-									fixes.push(
-										fixer.insertTextBefore(
-											dotToken,
-											'\n' + indent
-										)
-									);
+				}
 
-								}
-							);
-							return fixes;
+			} else if (enforceSingleLine) {
+
+				// --- Mode 2: Enforce single line if chain is short enough and option is enabled ---
+
+				for (const linkNode of links) {
+
+					const previousNode = linkNode.object;
+					const separatorToken = sourceCode.getTokenBefore(
+						linkNode.property,
+						{ filter: (token) => token.value === '.' || token.value === '?.' }
+					);
+
+					if (
+						separatorToken
+							.loc
+							.start
+							.line > previousNode
+							.loc
+							.end
+							.line
+					) {
+
+						context.report({
+							node: linkNode.property,
+							loc: separatorToken.loc,
+							messageId: 'noNewline',
+							fix: (fixer) => fixer.replaceTextRange(
+								[
+									previousNode.range[1],
+									separatorToken.range[0]
+								],
+								''
+							)
+						});
 
-						}
-					});
+					}
 
 				}
 
@@ -120,25 +217,12 @@ export const maxChainPerLineRule = {
 		}
 
 		return {
-			'MemberExpression:exit'(node) {
-
-				if (node.parent.type === 'MemberExpression' && node.parent.object === node)
-					return;
-				if (node.parent.type === 'CallExpression' && node.parent.callee === node)
-					return;
-				check(node);
-
-			},
-			'CallExpression:exit'(node) {
-
-				if (node.parent.type === 'MemberExpression' && node.parent.object === node)
-					return;
-				if (node.parent.type === 'CallExpression' && node.parent.callee === node)
-					return;
+			MemberExpression(node) {
 
-				if (isChainable(node.callee)) {
+				// Only start the check from non-computed MemberExpressions to avoid redundant checks.
+				if (!node.computed) {
 
-					check(node);
+					checkChain(node);
 
 				}