lint-rules-alvin 1.0.0

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

@@ -0,0 +1,100 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export const jsxNoSingleObjectCurlyNewlineRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Disallows newlines inside curly braces for single object or array expressions in JSX.',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'code',
+		schema: [],
+		messages: { error: 'Newlines around single object or array expressions in JSX curly braces are not allowed.' }
+	},
+
+	create(context) {
+
+		const sourceCode = context.sourceCode;
+
+		return {
+			JSXExpressionContainer(node) {
+
+				const expression = node.expression;
+
+				// This rule applies only to single ArrayExpressions or ObjectExpressions.
+				if (expression.type !== 'ArrayExpression' && expression.type !== 'ObjectExpression') {
+
+					return;
+
+				}
+
+				// If the expression itself isn't multiline, there are no newlines to collapse.
+				if (expression.loc.start.line === expression.loc.end.line) {
+
+					return;
+
+				}
+
+				const openingBrace = sourceCode.getFirstToken(node); // `{`
+				const closingBrace = sourceCode.getLastToken(node); // `}`
+				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;
+
+				if (hasNewlineBefore || hasNewlineAfter) {
+
+					context.report({
+						node,
+						messageId: 'error',
+						fix(fixer) {
+
+							const fixes = [];
+
+							if (hasNewlineBefore) {
+
+								// Range from the end of `{` to the start of the expression's first token.
+								const range = [
+									openingBrace.range[1],
+									firstTokenInExpression.range[0]
+								];
+								fixes.push(
+									fixer.replaceTextRange(
+										range,
+										''
+									)
+								);
+
+							}
+
+							if (hasNewlineAfter) {
+
+								// Range from the end of the expression's last token to the start of `}`.
+								const range = [
+									lastTokenInExpression.range[1],
+									closingBrace.range[0]
+								];
+								fixes.push(
+									fixer.replaceTextRange(
+										range,
+										''
+									)
+								);
+
+							}
+
+							return fixes;
+
+						}
+					});
+
+				}
+
+			}
+		};
+
+	}
+};

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

@@ -0,0 +1,149 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+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.',
+			category: 'Stylistic Issues'
+		},
+		fixable: 'whitespace',
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					maxChain: {
+						type: 'integer',
+						minimum: 1
+					}
+				},
+				additionalProperties: false
+			}
+		],
+		messages: { expectedNewline: 'This call chain is too long and should be broken into multiple lines.' }
+	},
+	create(context) {
+
+		const options = context.options[0] || {};
+		const maxChain = options.maxChain || 2;
+		const sourceCode = context.sourceCode;
+
+		function isChainable(node) {
+
+			if (!node)
+				return false;
+			return node.type === 'MemberExpression' || node.type === 'CallExpression';
+
+		}
+
+		function check(node) {
+
+			const members = [];
+			let callCount = 0;
+			let current = node;
+
+			while (isChainable(current)) {
+
+				if (current.type === 'CallExpression') {
+
+					callCount++;
+					current = current.callee;
+
+				} else { // MemberExpression
+
+					members.unshift(current);
+					current = current.object;
+
+				}
+
+			}
+			const root = current;
+			const totalChainLength = members.length + 1;
+
+			let iter = node;
+			while(isChainable(iter)) {
+
+				if (iter.type === 'CallExpression') {
+
+					callCount++;
+
+				}
+				iter = iter.type === 'CallExpression'
+					? iter.callee
+					: iter.object;
+
+			}
+
+			const isMultiline = root.loc.start.line !== node.loc.end.line;
+
+			if (callCount > 0) {
+
+				if (!isMultiline && totalChainLength > maxChain) {
+
+					context.report({
+						node: node,
+						messageId: 'expectedNewline',
+						fix(fixer) {
+
+							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;
+
+						}
+					});
+
+				}
+
+			}
+
+		}
+
+		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;
+
+				if (isChainable(node.callee)) {
+
+					check(node);
+
+				}
+
+			}
+		};
+
+	}
+};

package/eslint/custom_rules/multiline-paren-newline.js

@@ -0,0 +1,153 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export const multilineParenNewlineRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Require newlines inside parentheses of call expressions that are multiline',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'whitespace',
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					singleArgument: {
+						type: 'boolean',
+						default: false
+					}
+				},
+				additionalProperties: false
+			}
+		],
+		messages: {
+			expectedNewlineAfterParen: 'Expected a newline after \'(\'.',
+			expectedNewlineBeforeParen: 'Expected a newline before \')\'.'
+		}
+	},
+
+	create(context) {
+
+		const sourceCode = context.sourceCode;
+		const options = context.options[0] || {};
+		const allowSingleArgumentOnSameLine = options.singleArgument === true;
+
+		/**
+		 * @param {import('estree').CallExpression} node
+		 */
+		function check(node) {
+
+			// Get the opening parenthesis token.
+			const openParen = sourceCode.getTokenAfter(node.callee);
+
+			// Get the closing parenthesis token.
+			const closeParen = sourceCode.getLastToken(node);
+
+			// If we can't find the parentheses, or they aren't parentheses, exit.
+			if (!openParen || openParen.value !== '(' || !closeParen || closeParen.value !== ')') {
+
+				return;
+
+			}
+
+			// If the parentheses are on the same line, this rule doesn't apply.
+			if (openParen.loc.start.line === closeParen.loc.end.line) {
+
+				return;
+
+			}
+
+			// Handle the singleArgument exception
+			if (
+				allowSingleArgumentOnSameLine
+				&& node.arguments.length === 1
+			) {
+
+				const arg = node.arguments[0];
+				const isObjectOrArray = arg.type === 'ObjectExpression' || arg.type === 'ArrayExpression';
+
+				if (isObjectOrArray) {
+
+					// For this exception, we *disallow* newlines between parens and the single argument.
+					const firstTokenOfArg = sourceCode.getFirstToken(arg);
+					if (openParen.loc.end.line !== firstTokenOfArg.loc.start.line) {
+
+						context.report({
+							node: openParen,
+							message: 'Unexpected newline after \'(\' for single object/array argument.',
+							fix: (fixer) => fixer.removeRange([
+								openParen.range[1],
+								firstTokenOfArg.range[0]
+							])
+						});
+
+					}
+
+					const lastTokenOfArg = sourceCode.getLastToken(arg);
+					if (lastTokenOfArg.loc.end.line !== closeParen.loc.start.line) {
+
+						context.report({
+							node: closeParen,
+							message: 'Unexpected newline before \')\' for single object/array argument.',
+							fix: (fixer) => fixer.removeRange([
+								lastTokenOfArg.range[1],
+								closeParen.range[0]
+							])
+						});
+
+					}
+
+					return; // End processing for this node
+
+				}
+
+			}
+
+			// Check for a newline after the opening parenthesis.
+			const firstArg = node.arguments[0];
+			if (firstArg) {
+
+				const firstTokenOfFirstArg = sourceCode.getFirstToken(firstArg);
+				if (openParen.loc.end.line === firstTokenOfFirstArg.loc.start.line) {
+
+					context.report({
+						node: openParen,
+						messageId: 'expectedNewlineAfterParen',
+						fix: (fixer) => fixer.insertTextAfter(
+							openParen,
+							'\n'
+						)
+					});
+
+				}
+
+			}
+
+			// Check for a newline before the closing parenthesis.
+			const lastArg = node.arguments[node.arguments.length - 1];
+			if (lastArg) {
+
+				const lastTokenOfLastArg = sourceCode.getLastToken(lastArg);
+				if (lastTokenOfLastArg.loc.end.line === closeParen.loc.start.line) {
+
+					context.report({
+						node: closeParen,
+						messageId: 'expectedNewlineBeforeParen',
+						fix: (fixer) => fixer.insertTextBefore(
+							closeParen,
+							'\n'
+						)
+					});
+
+				}
+
+			}
+
+		}
+
+		return { CallExpression: check };
+
+	}
+};

package/eslint/custom_rules/newline-between-imports.js

@@ -0,0 +1,77 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export const newlineBetweenImportsRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce newlines between import specifiers',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'whitespace',
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					minItems: {
+						type: 'integer',
+						minimum: 2
+					}
+				},
+				additionalProperties: false
+			}
+		],
+		messages: { error: 'There should be a newline between import specifiers.' }
+	},
+
+	create(context) {
+
+		const sourceCode = context.sourceCode;
+		const { minItems = 2 } = context.options[0] || {};
+
+		return {
+			ImportDeclaration(node) {
+
+				const specifiers = node
+					.specifiers
+					.filter((specifier) => specifier.type === 'ImportSpecifier');
+
+				if (specifiers.length < minItems) {
+
+					return;
+
+				}
+
+				for (let i = 0; i < specifiers.length - 1; i++) {
+
+					const currentSpecifier = specifiers[i];
+					const nextSpecifier = specifiers[i + 1];
+
+					const lastTokenOfCurrent = sourceCode.getLastToken(currentSpecifier);
+					const firstTokenOfNext = sourceCode.getFirstToken(nextSpecifier);
+
+					if (lastTokenOfCurrent.loc.end.line === firstTokenOfNext.loc.start.line) {
+
+						context.report({
+							node: nextSpecifier,
+							messageId: 'error',
+							fix(fixer) {
+
+								return fixer.insertTextBefore(
+									nextSpecifier,
+									'\n'
+								);
+
+							}
+						});
+
+					}
+
+				}
+
+			}
+		};
+
+	}
+};

package/eslint/custom_rules/unnamed-imports-last.js

@@ -0,0 +1,84 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export const unnamedImportsLastRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce that unnamed imports (side-effect imports) are last',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'code',
+		schema: [],
+		messages: { error: 'Unnamed (side-effect) imports should be at the bottom of the import block.' }
+	},
+
+	create(context) {
+
+		return {
+			'Program:exit'(program) {
+
+				const sourceCode = context.sourceCode;
+				const allImports = program
+					.body
+					.filter((node) => node.type === 'ImportDeclaration');
+
+				if (allImports.length < 2) {
+
+					return;
+
+				}
+
+				const regularImports = allImports.filter((node) => node.specifiers.length > 0);
+				const sideEffectImports = allImports.filter((node) => node.specifiers.length === 0);
+
+				if (regularImports.length === 0 || sideEffectImports.length === 0) {
+
+					return;
+
+				}
+
+				const lastRegularImport = regularImports[regularImports.length - 1];
+
+				const misplacedImports = sideEffectImports.filter((node) => node.range[0] < lastRegularImport.range[0]);
+
+				if (misplacedImports.length === 0) {
+
+					return;
+
+				}
+
+				// Report on the first misplaced import
+				const firstMisplaced = misplacedImports[0];
+
+				context.report({
+					node: firstMisplaced,
+					messageId: 'error',
+					fix(fixer) {
+
+						const sortedImports = [
+							...regularImports,
+							...sideEffectImports
+						];
+
+						const importTexts = sortedImports.map((node) => sourceCode.getText(node));
+
+						const range = [
+							allImports[0].range[0],
+							allImports[allImports.length - 1].range[1]
+						];
+
+						return fixer.replaceTextRange(
+							range,
+							importTexts.join('\n')
+						);
+
+					}
+				});
+
+			}
+		};
+
+	}
+};

package/eslint/presets/astroReact.js

@@ -0,0 +1,33 @@
+import { defineConfig } from 'eslint/config';
+import { importX as eslintPluginImportX } from 'eslint-plugin-import-x';
+import {
+	base,
+	astro,
+	importX,
+	reactHooks,
+	stylistic,
+	custom
+} from '../configs/index.js';
+
+/**
+ * The `ESLint` Astro/React config with typescript.
+ */
+export const astroReact = defineConfig(
+	base,
+	astro,
+	{
+		...eslintPluginImportX.configs['flat/react'],
+		...importX
+	},
+	reactHooks,
+	stylistic,
+	custom,
+	{
+		name: 'eslint-plugin-astro-stylistic-override',
+		files: [ '**/*.astro' ],
+		rules: {
+			'@stylistic/jsx-one-expression-per-line': 'off',
+			'@stylistic/jsx-curly-brace-presence': 'off'
+		}
+	}
+);

package/eslint/presets/astroReactTs.js

@@ -0,0 +1,39 @@
+import {
+	defineConfig,
+	globalIgnores
+} from 'eslint/config';
+import { importX as eslintPluginImportX } from 'eslint-plugin-import-x';
+import {
+	base,
+	custom,
+	astro,
+	typescript,
+	reactHooks,
+	stylistic,
+	importXTs
+} from '../configs/index.js';
+
+/**
+ * The `ESLint` Astro/React config with typescript.
+ */
+export const astroReactTs = defineConfig(
+	base,
+	globalIgnores([ '**/*.astro/*.ts' ]),
+	typescript,
+	astro,
+	{
+		...eslintPluginImportX.configs['flat/react'],
+		...importXTs
+	},
+	reactHooks,
+	stylistic,
+	custom,
+	{
+		name: 'eslint-plugin-astro-stylistic-override',
+		files: [ '**/*.astro' ],
+		rules: {
+			'@stylistic/jsx-one-expression-per-line': 'off',
+			'@stylistic/jsx-curly-brace-presence': 'off'
+		}
+	}
+);

package/eslint/presets/index.d.ts

@@ -0,0 +1,14 @@
+import type { Linter } from 'eslint';
+
+/**
+ * ESLint preset for Astro/React with JavaScript.
+ *
+ * This package uses ESLint's flat config format, so the preset is an array
+ * of flat-config items.
+ */
+export declare const astroReact: readonly Linter.Config[];
+
+/**
+ * ESLint preset for Astro/React with TypeScript.
+ */
+export declare const astroReactTs: readonly Linter.Config[];

package/eslint/presets/index.js

@@ -0,0 +1,2 @@
+export { astroReact } from './astroReact';
+export { astroReactTs } from './astroReactTs';

package/eslint.config.js

@@ -0,0 +1,17 @@
+import { defineConfig, globalIgnores } from 'eslint/config';
+import {
+	base,
+	importX,
+	json,
+	stylistic,
+	custom
+} from './eslint/configs/index.js';
+
+export default defineConfig(
+	globalIgnores(['**/*.d.ts']),
+	base,
+	importX,
+	stylistic,
+	json,
+	custom
+);