lint-rules-alvin 1.0.0

package/eslint/configs/typescript.js

@@ -0,0 +1,398 @@
+import eslintTs from 'typescript-eslint';
+
+export const typescript = {
+	name: 'typescript',
+	extends: [ eslintTs.configs.recommendedTypeChecked ],
+	languageOptions: { parserOptions: { projectService: true } },
+	rules: {
+		'@typescript-eslint/array-type': [
+			'error',
+			{
+				default: 'array',
+				readonly: 'array'
+			}
+		],
+		'@typescript-eslint/class-literal-property-style': [
+			'error',
+			'fields'
+		],
+		'@typescript-eslint/consistent-indexed-object-style': [
+			'error',
+			'record'
+		],
+		'@typescript-eslint/consistent-type-exports': 'error',
+		'@typescript-eslint/consistent-type-imports': 'off', // Prefer import/ rule over this
+		'@typescript-eslint/consistent-type-assertions': [
+			'error',
+			{
+				assertionStyle: 'as',
+				arrayLiteralTypeAssertions: 'allow',
+				objectLiteralTypeAssertions: 'allow'
+			}
+		],
+		'dot-notation': 'off',
+		'@typescript-eslint/dot-notation': [
+			'error',
+			{
+				allowPrivateClassPropertyAccess: false,
+				allowProtectedClassPropertyAccess: false,
+				allowIndexSignaturePropertyAccess: false
+			}
+		],
+		'@typescript-eslint/explicit-function-return-type': 'off',
+		'max-params': 'off',
+		'@typescript-eslint/max-params': [
+			'warn',
+			{
+				max: 3,
+				countVoidThis: false
+			}
+		],
+		'@typescript-eslint/member-ordering': [
+			'error',
+			{
+				default: {
+					memberTypes: [
+					// Index signature
+						'signature',
+						'call-signature',
+
+						// Fields
+						'public-static-field',
+						'protected-static-field',
+						'private-static-field',
+						'#private-static-field',
+
+						'public-decorated-field',
+						'protected-decorated-field',
+						'private-decorated-field',
+
+						'public-instance-field',
+						'protected-instance-field',
+						'private-instance-field',
+						'#private-instance-field',
+
+						'public-abstract-field',
+						'protected-abstract-field',
+
+						'public-field',
+						'protected-field',
+						'private-field',
+						'#private-field',
+
+						'static-field',
+						'instance-field',
+						'abstract-field',
+
+						'decorated-field',
+
+						'field',
+
+						// Static initialization
+						'static-initialization',
+
+						// Constructors
+						'public-constructor',
+						'protected-constructor',
+						'private-constructor',
+
+						'constructor',
+
+						// Accessors
+						'public-static-accessor',
+						'protected-static-accessor',
+						'private-static-accessor',
+						'#private-static-accessor',
+
+						'public-decorated-accessor',
+						'protected-decorated-accessor',
+						'private-decorated-accessor',
+
+						'public-instance-accessor',
+						'protected-instance-accessor',
+						'private-instance-accessor',
+						'#private-instance-accessor',
+
+						'public-abstract-accessor',
+						'protected-abstract-accessor',
+
+						'public-accessor',
+						'protected-accessor',
+						'private-accessor',
+						'#private-accessor',
+
+						'static-accessor',
+						'instance-accessor',
+						'abstract-accessor',
+
+						'decorated-accessor',
+
+						'accessor',
+
+						// Getters
+						'public-static-get',
+						'protected-static-get',
+						'private-static-get',
+						'#private-static-get',
+
+						'public-decorated-get',
+						'protected-decorated-get',
+						'private-decorated-get',
+
+						'public-instance-get',
+						'protected-instance-get',
+						'private-instance-get',
+						'#private-instance-get',
+
+						'public-abstract-get',
+						'protected-abstract-get',
+
+						'public-get',
+						'protected-get',
+						'private-get',
+						'#private-get',
+
+						'static-get',
+						'instance-get',
+						'abstract-get',
+
+						'decorated-get',
+
+						'get',
+
+						// Setters
+						'public-static-set',
+						'protected-static-set',
+						'private-static-set',
+						'#private-static-set',
+
+						'public-decorated-set',
+						'protected-decorated-set',
+						'private-decorated-set',
+
+						'public-instance-set',
+						'protected-instance-set',
+						'private-instance-set',
+						'#private-instance-set',
+
+						'public-abstract-set',
+						'protected-abstract-set',
+
+						'public-set',
+						'protected-set',
+						'private-set',
+						'#private-set',
+
+						'static-set',
+						'instance-set',
+						'abstract-set',
+
+						'decorated-set',
+
+						'set',
+
+						// Methods
+						'public-static-method',
+						'protected-static-method',
+						'private-static-method',
+						'#private-static-method',
+
+						'public-decorated-method',
+						'protected-decorated-method',
+						'private-decorated-method',
+
+						'public-instance-method',
+						'protected-instance-method',
+						'private-instance-method',
+						'#private-instance-method',
+
+						'public-abstract-method',
+						'protected-abstract-method',
+
+						'public-method',
+						'protected-method',
+						'private-method',
+						'#private-method',
+
+						'static-method',
+						'instance-method',
+						'abstract-method',
+
+						'decorated-method',
+
+						'method'
+					]
+				}
+			}
+		],
+		'@typescript-eslint/method-signature-style': [
+			'error',
+			'property'
+		],
+		'@typescript-eslint/naming-convention': [
+			'error',
+			{
+				selector: 'default',
+				format: [
+					'camelCase',
+					'PascalCase',
+					'UPPER_CASE',
+					'snake_case'
+				],
+				leadingUnderscore: 'forbid',
+				trailingUnderscore: 'forbid'
+			},
+			{
+				selector: 'memberLike', // classicAccessor, autoAccessor, enumMember, method, parameterProperty, property
+				format: [
+					'camelCase',
+					'PascalCase',
+					'UPPER_CASE',
+					'snake_case'
+				],
+				leadingUnderscore: 'forbid',
+				trailingUnderscore: 'forbid'
+			},
+			{
+				selector: 'accessor', // classicAccessor, autoAccessor
+				format: [
+					'camelCase',
+					'PascalCase',
+					'UPPER_CASE',
+					'snake_case'
+				],
+				leadingUnderscore: 'forbid',
+				trailingUnderscore: 'forbid'
+			},
+			{
+				selector: 'method', // classMethod, objectLiteralMethod, typeMethod
+				format: [
+					'camelCase',
+					'PascalCase',
+					'snake_case'
+				],
+				leadingUnderscore: 'forbid',
+				trailingUnderscore: 'forbid'
+			},
+			{
+				selector: 'property', // classProperty, objectLiteralProperty, typeProperty
+				format: [
+					'camelCase',
+					'UPPER_CASE'
+				],
+				leadingUnderscore: 'allow',
+				trailingUnderscore: 'forbid'
+			},
+			{
+				selector: 'typeLike', // class, enum, interface, typeAlias, typeParameter
+				format: [ 'PascalCase' ],
+				leadingUnderscore: 'allow',
+				trailingUnderscore: 'allow'
+			},
+			{
+				selector: 'variableLike', // function, parameter, variable
+				format: [],
+				leadingUnderscore: 'allow',
+				trailingUnderscore: 'allow'
+			},
+			{
+				selector: 'import',
+				format: [
+					'camelCase',
+					'PascalCase'
+				],
+				leadingUnderscore: 'forbid',
+				trailingUnderscore: 'forbid'
+			},
+			{
+				selector: 'objectLiteralProperty',
+				format: [],
+				leadingUnderscore: 'allow',
+				trailingUnderscore: 'allow'
+			}
+		],
+		'no-array-constructor': 'off',
+		'@typescript-eslint/no-array-constructor': 'error',
+		'@typescript-eslint/no-array-delete': 'warn',
+		'@typescript-eslint/no-base-to-string': 'error',
+		'@typescript-eslint/no-confusing-non-null-assertion': 'error',
+		'@typescript-eslint/no-confusing-void-expression': 'error',
+		'@typescript-eslint/no-deprecated': 'error',
+		'@typescript-eslint/no-dupe-class-members': 'error',
+		'@typescript-eslint/no-duplicate-enum-values': 'error',
+		'@typescript-eslint/no-duplicate-type-constituents': 'error',
+		'@typescript-eslint/no-dynamic-delete': 'error',
+		'@typescript-eslint/no-empty-function': 'warn',
+		'@typescript-eslint/no-empty-interface': 'warn',
+		'@typescript-eslint/no-empty-object-type': 'warn',
+		'@typescript-eslint/no-explicit-any': 'off',
+		'@typescript-eslint/no-extra-non-null-assertion': 'error',
+		'@typescript-eslint/no-extraneous-class': 'error',
+		'@typescript-eslint/no-floating-promises': [
+			'error',
+			{
+				checkThenables: false,
+				ignoreIIFE: false,
+				ignoreVoid: true
+			}
+		],
+		'@typescript-eslint/no-for-in-array': 'error',
+		'no-implied-eval': 'off',
+		'@typescript-eslint/no-implied-eval': 'error',
+		'@typescript-eslint/no-invalid-void-type': [
+			'error',
+			{
+				allowInGenericTypeArguments: true,
+				allowAsThisParameter: false
+			}
+		],
+		'no-loop-func': 'off',
+		'@typescript-eslint/no-loop-func': 'error',
+		'no-magic-numbers': 'off',
+		'@typescript-eslint/no-magic-numbers': 'off',
+		'@typescript-eslint/no-meaningless-void-operator': [
+			'error',
+			{ checkNever: true }
+		],
+		'@typescript-eslint/no-misused-new': 'error',
+		'@typescript-eslint/no-misused-promises': [
+			'error',
+			{
+				checksConditionals: true,
+				checksVoidReturn: true,
+				checksSpreads: true
+			}
+		],
+		'@typescript-eslint/no-misused-spread': 'error',
+		'@typescript-eslint/no-mixed-enums': 'error',
+		'@typescript-eslint/no-namespace': [
+			'error',
+			{
+				allowDeclarations: false,
+				allowDefinitionFiles: true
+			}
+		],
+		'no-shadow': 'off',
+		'@typescript-eslint/no-shadow': [
+			'error',
+			{
+				builtinGlobals: true,
+				hoist: 'functions',
+				ignoreOnInitialization: false,
+				ignoreTypeValueShadow: true,
+				ignoreFunctionTypeParameterNameValueShadow: false
+			}
+		],
+		'@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error',
+		'@typescript-eslint/no-unnecessary-condition': 'error',
+		'@typescript-eslint/no-unnecessary-parameter-property-assignment': 'error',
+		'@typescript-eslint/no-unnecessary-qualifier': 'error',
+		'@typescript-eslint/no-unnecessary-template-expression': 'error',
+		'@typescript-eslint/no-unnecessary-type-arguments': 'error',
+		'@typescript-eslint/no-unnecessary-type-assertion': 'error',
+		'@typescript-eslint/no-unnecessary-type-constraint': 'error',
+		'@typescript-eslint/no-unnecessary-type-conversion': 'error',
+		'@typescript-eslint/no-unnecessary-type-parameters': 'error'
+
+	}
+};

package/eslint/custom_rules/chain-first-on-newline.js

@@ -0,0 +1,174 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export const chainFirstOnNewlineRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce or forbid a newline before the first element in a chained expression.',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'whitespace',
+		schema: [
+			{
+				enum: [
+					'require',
+					'forbid'
+				]
+			}
+		],
+		messages: {
+			require: 'Expected a newline before the first element of the chain.',
+			forbid: 'Unexpected newline before the first element of the chain.'
+		}
+	},
+
+	create(context) {
+
+		const sourceCode = context.sourceCode;
+		const option = context.options[0] || 'require';
+
+		function isChainable(node) {
+
+			if (!node)
+				return false;
+			return node.type === 'MemberExpression' || node.type === 'CallExpression';
+
+		}
+
+		function check(node) { // node is the end of the chain
+
+			let firstMemberExpr = null;
+			let current = node;
+
+			// Traverse down to find the root and the first member expression
+			while (isChainable(current)) {
+
+				if (current.type === 'MemberExpression') {
+
+					firstMemberExpr = current;
+					current = current.object;
+
+				} else { // CallExpression
+
+					current = current.callee;
+
+				}
+
+			}
+			const root = current;
+
+			if (!firstMemberExpr) {
+
+				return;
+
+			}
+
+			const endOfChainNode = node.type === 'CallExpression'
+				? node.callee
+				: node;
+
+			// Ignore single-line chains.
+			if (root.loc.start.line === endOfChainNode.loc.end.line) {
+
+				return;
+
+			}
+
+			const object = firstMemberExpr.object;
+			const property = firstMemberExpr.property;
+
+			const dotToken = sourceCode.getTokenBefore(property);
+
+			const objectEndLine = object.loc.end.line;
+			const propertyStartLine = dotToken.loc.start.line;
+
+			const isSameLine = objectEndLine === propertyStartLine;
+
+			if (option === 'require') {
+
+				if (isSameLine) {
+
+					context
+						.report({
+							node: property,
+							messageId: 'require',
+							loc: dotToken.loc,
+							fix(fixer) {
+
+								return fixer
+									.insertTextBefore(
+										dotToken,
+										'\n'
+									);
+
+							}
+						});
+
+				}
+
+			} else { // 'forbid'
+
+				if (!isSameLine) {
+
+					context
+						.report({
+							node: property,
+							messageId: 'forbid',
+							loc: dotToken.loc,
+							fix(fixer) {
+
+								const rangeToRemove = [
+									object.range[1],
+									dotToken.range[0]
+								];
+								return fixer.removeRange(rangeToRemove);
+
+							}
+						});
+
+				}
+
+			}
+
+		}
+
+		return {
+			'MemberExpression:exit'(node) {
+
+				if (node.parent.type === 'MemberExpression' && node.parent.object === node)
+					return;
+				if (node.parent.type === 'CallExpression' && node.parent.callee === node)
+					return;
+				if (node.parent.type === 'CallExpression' && node
+					.parent
+					.arguments
+					.includes(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 (node.parent.type === 'CallExpression'
+					&& node
+						.parent
+						.arguments
+						.includes(node))
+					return;
+				if (isChainable(node.callee)) {
+
+					check(node);
+
+				}
+
+			}
+		};
+
+	}
+};

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

@@ -0,0 +1,99 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export const jsxMultilinePropNewlineRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforces a new line for the first prop if any prop\'s value is multiline.',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'code',
+		schema: [],
+		messages: { error: 'The first property should be on a new line if any property\'s value is multiline.' }
+	},
+
+	create(context) {
+
+		const sourceCode = context.sourceCode;
+
+		function isMultiline(node) {
+
+			return node && node.loc && node.loc.start.line < node.loc.end.line;
+
+		}
+
+		return {
+			JSXOpeningElement(node) {
+
+				if (node.attributes.length === 0) {
+
+					return;
+
+				}
+
+				const hasMultilineProp = node.attributes.some(
+					(attr) => {
+
+						// Check for JSXAttribute (e.g., href={...})
+						if (attr.type === 'JSXAttribute') {
+
+							return isMultiline(attr.value);
+
+						}
+
+						// Check for JSXSpreadAttribute (e.g., {...props})
+						if (attr.type === 'JSXSpreadAttribute') {
+
+							return isMultiline(attr);
+
+						}
+						return false;
+
+					}
+				);
+
+				if (!hasMultilineProp) {
+
+					return;
+
+				}
+
+				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) {
+
+					context.report({
+						node: firstProp,
+						messageId: 'error',
+						fix(fixer) {
+
+							// Get indentation of the line with the opening tag.
+							const line = sourceCode
+								.getLines()
+								[node.loc.start.line - 1];
+							const baseIndentMatch = line.match(/^\s*/);
+							const baseIndent = baseIndentMatch
+								? baseIndentMatch[0]
+								: '';
+
+							// Assume an indent of 2 spaces, a common practice.
+							const indent = baseIndent + '  ';
+
+							return fixer.insertTextBefore(
+								firstProp,
+								`\n${indent}`
+							);
+
+						}
+					});
+
+				}
+
+			}
+		};
+
+	}
+};