lint-rules-alvin 1.1.3 → 1.1.4

package/eslint/configs/custom.js

@@ -1,7 +1,6 @@
 import { newlineBetweenImportsRule } from '../custom_rules/newline-between-imports.js';
 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 { multilineParenNewlineRule } from '../custom_rules/multiline-paren-newline.js';
 import { multilineArrayAccessorNewlineRule } from '../custom_rules/multiline-array-accessor-newline.js';
@@ -19,7 +18,6 @@ export const custom = {
 				'newline-between-imports': newlineBetweenImportsRule,
 				'unnamed-imports-last': unnamedImportsLastRule,
 				'jsx-multiline-prop-newline': jsxMultilinePropNewlineRule,
-				'jsx-no-single-object-curly-newline': jsxNoSingleObjectCurlyNewlineRule,
 				'max-chain-per-line': maxChainPerLineRule,
 				'multiline-paren-newline': multilineParenNewlineRule,
 				'multiline-array-accessor-newline': multilineArrayAccessorNewlineRule,
@@ -33,8 +31,13 @@ export const custom = {
 			{ minItems: 2 }
 		],
 		'custom/unnamed-imports-last': 'error',
-		'custom/jsx-multiline-prop-newline': 'error',
-		'custom/jsx-no-single-object-curly-newline': 'error',
+		'custom/jsx-multiline-prop-newline': [
+			'error',
+			{
+				enforceSingleLine: true,
+				allowSingleExpression: true
+			}
+		],
 		'custom/max-chain-per-line': [
 			'error',
 			{

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

@@ -5,108 +5,199 @@ export const jsxMultilinePropNewlineRule = {
 	meta: {
 		type: 'layout',
 		docs: {
-			description: 'Enforces a new line for the first prop if any prop\'s value is multiline.',
+			description: 'Enforces newline consistency for JSX properties.',
 			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.' }
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					enforceSingleLine: {
+						type: 'boolean',
+						default: false
+					},
+					allowSingleExpression: {
+						type: 'boolean',
+						default: true
+					}
+				},
+				additionalProperties: false
+			}
+		],
+		messages: {
+			collapse: 'This expression should not be surrounded by newlines.',
+			expand: 'This multiline expression should be surrounded by newlines.'
+		}
 	},
-
 	create(context) {
 
+		const {
+			allowSingleExpression = true,
+			enforceSingleLine = false
+		} = context.options[0] || {};
 		const sourceCode = context.sourceCode;
 
-		function isMultiline(node) {
-
-			return node && node.loc && node
-				.loc
-				.start
-				.line < node
-				.loc
-				.end
-				.line;
-
-		}
-
 		return {
-			JSXOpeningElement(node) {
+			JSXExpressionContainer(node) {
 
-				if (node.attributes.length === 0) {
+				if (node.parent.type !== 'JSXAttribute' || node.expression.type === 'JSXEmptyExpression') {
 
 					return;
 
 				}
 
-				const hasMultilineProp = node.attributes.some(
-					(attr) => {
+				const openingBrace = sourceCode.getFirstToken(node);
+				const closingBrace = sourceCode.getLastToken(node);
+				const expression = node.expression;
+
+				const expressionIsMultiline = expression
+					.loc
+					.start
+					.line !== expression
+					.loc
+					.end
+					.line;
+
+				const hasNewlineAfter = openingBrace
+					.loc
+					.end
+					.line !== expression
+					.loc
+					.start
+					.line;
+				const hasNewlineBefore = expression
+					.loc
+					.end
+					.line !== closingBrace
+					.loc
+					.start
+					.line;
+
+				if (expressionIsMultiline) {
+
+					const isSingleObjectOrArray = expression.type === 'ObjectExpression' || expression.type === 'ArrayExpression';
+
+					if (allowSingleExpression && isSingleObjectOrArray) {
+
+						// Collapse newlines for single multiline Object/Array
+						if (hasNewlineAfter || hasNewlineBefore) {
+
+							context.report({
+								node,
+								messageId: 'collapse',
+								fix(fixer) {
+
+									const fixes = [];
+									if (hasNewlineAfter) {
+
+										fixes.push(
+											fixer.removeRange([
+												openingBrace.range[1],
+												expression.range[0]
+											])
+										);
+
+									}
+									if (hasNewlineBefore) {
+
+										fixes.push(
+											fixer.removeRange([
+												expression.range[1],
+												closingBrace.range[0]
+											])
+										);
+
+									}
+									return fixes;
+
+								}
+							});
 
-						// Check for JSXAttribute (e.g., href={...})
-						if (attr.type === 'JSXAttribute') {
+						}
 
-							return isMultiline(attr.value);
+					} else {
 
-						}
+						// Enforce newlines for other multiline expressions
+						if (!hasNewlineAfter || !hasNewlineBefore) {
+
+							context.report({
+								node,
+								messageId: 'expand',
+								fix(fixer) {
+
+									const fixes = [];
+									if (!hasNewlineAfter) {
+
+										fixes.push(
+											fixer.insertTextAfter(
+												openingBrace,
+												'\n'
+											)
+										);
 
-						// Check for JSXSpreadAttribute (e.g., {...props})
-						if (attr.type === 'JSXSpreadAttribute') {
+									}
+									if (!hasNewlineBefore) {
 
-							return isMultiline(attr);
+										fixes.push(
+											fixer.insertTextBefore(
+												closingBrace,
+												'\n'
+											)
+										);
+
+									}
+									return fixes;
+
+								}
+							});
 
 						}
-						return false;
 
 					}
-				);
 
-				if (!hasMultilineProp) {
+				} else { // Single-line expression
 
-					return;
+					if (enforceSingleLine) {
 
-				}
+						// Collapse newlines
+						if (hasNewlineAfter || hasNewlineBefore) {
+
+							context.report({
+								node,
+								messageId: 'collapse',
+								fix(fixer) {
+
+									const fixes = [];
+									if (hasNewlineAfter) {
 
-				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}`
-							);
+										fixes.push(
+											fixer.removeRange([
+												openingBrace.range[1],
+												expression.range[0]
+											])
+										);
+
+									}
+									if (hasNewlineBefore) {
+
+										fixes.push(
+											fixer.removeRange([
+												expression.range[1],
+												closingBrace.range[0]
+											])
+										);
+
+									}
+									return fixes;
+
+								}
+							});
 
 						}
-					});
+
+					}
 
 				}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-rules-alvin",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "My own personal linting ruleset for a bunch of different plugins. Includes a few custom rules. Used in a few of my repos.",
   "keywords": [
     "eslint"

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

@@ -1,120 +0,0 @@
-/**
- * @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;
-
-						}
-					});
-
-				}
-
-			}
-		};
-
-	}
-};