linter-bundle 7.1.1 → 7.2.0

package/CHANGELOG.md

@@ -6,7 +6,35 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
-[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v7.1.1...HEAD)
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v7.1.2...HEAD)
+
+## [7.2.0] - 2025-03-18
+
+### Changed
+
+- [eslint] Updated `eslint-import-resolver-typescript` from `3.9.0` to `4.2.0`
+- [eslint] Updated `eslint-plugin-jsdoc` from `50.6.6` to `50.6.8`
+- [eslint/jest] Disabled `import/dynamic-import-chunkname` rule for tests
+- [eslint] Adjusted `padding-line-between-statements` rule, to enforce empty line around directives (like `"use client";`)
+- [eslint/react] Adjusted `@typescript-eslint/no-empty-object-type` rule, to allow empty interfaces with the suffix `Props` in TSX files
+- [eslint] Optimized position of closing parenthesis in `enforce-logical-expression-parens` and `enforce-ternary-parens` rule
+
+### Added
+
+- Re-added fixers of the mocked stylistic Stylelint rule.
+
+## [7.1.2] - 2025-03-15
+
+### Fixed
+
+- [eslint] Add line-break before variable declarations groups
+
+### Changed
+
+- [eslint] Optimize parens position of `enforce-logical-expression-parens` and `enforce-ternary-parens`
+- [eslint] Improve `eslint.config.mjs` code example in [README.md](./README.md)
+
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v7.1.1...v7.1.2)
 
 ## [7.1.1] - 2025-03-15
 

package/README.md

@@ -93,17 +93,28 @@ npm install linter-bundle --save-dev
 #### eslint.config.mjs
 
 ```js
+import gatsbyConfig from './eslint/gatsby.mjs';
+import javascriptConfig from './eslint/javascript.mjs';
+// import javascriptLazyConfig from './eslint/javascript-lazy.mjs';
+import jestConfig from './eslint/jest.mjs';
+import jsdocConfig from './eslint/jsdoc.mjs';
+import reactConfig from './eslint/react.mjs';
+import storybookConfig from './eslint/storybook.mjs';
+import typeDeclarationsConfig from './eslint/type-declarations.mjs';
+import workerConfig from './eslint/worker.mjs';
+import eslintConfig from './eslint.mjs';
+
 export default [
-  ...(await import('linter-bundle/eslint.mjs')).default,
-  // ...(await import('linter-bundle/eslint/gatsby.mjs')).default,
-  // ...(await import('linter-bundle/eslint/javascript.mjs')).default,
-  ...(await import('linter-bundle/eslint/javascript-lazy.mjs')).default,
-  // ...(await import('linter-bundle/eslint/jest.mjs')).default,
-  ...(await import('linter-bundle/eslint/jsdoc.mjs')).default,
-  // ...(await import('linter-bundle/eslint/react.mjs')).default,
-  // ...(await import('linter-bundle/eslint/storybook.mjs')).default,
-  // ...(await import('linter-bundle/eslint/type-declarations.mjs')).default,
-  // ...(await import('linter-bundle/eslint/worker.mjs')).default
+  ...eslintConfig,
+  ...gatsbyConfig,
+  ...javascriptConfig,
+  // ...javascriptLazyConfig,
+  ...jsdocConfig,
+  ...reactConfig,
+  ...storybookConfig,
+  ...typeDeclarationsConfig,
+  ...workerConfig
+  ...jestConfig,
 ]
 ```
 

package/eslint/index.mjs

@@ -392,9 +392,12 @@ export default [
 				'error',
 				{ blankLine: 'always', prev: '*', next: ['return', 'throw', 'break', 'continue'] },
 				{ blankLine: 'always', prev: ['const', 'let', 'var'], next: '*' },
+				{ blankLine: 'always', prev: '*', next: ['const', 'let', 'var'] },
 				{ blankLine: 'any', prev: ['const', 'let', 'var'], next: ['const', 'let', 'var'] },
 				{ blankLine: 'always', prev: '*', next: 'multiline-block-like' },
-				{ blankLine: 'always', prev: 'multiline-block-like', next: '*' }
+				{ blankLine: 'always', prev: 'multiline-block-like', next: '*' },
+				{ blankLine: 'always', prev: '*', next: 'directive' },
+				{ blankLine: 'always', prev: 'directive', next: '*' }
 			],
 			'prefer-arrow-callback': ['error', { allowNamedFunctions: true }],
 			'prefer-const': 'error',
@@ -1015,11 +1018,23 @@ export default [
 			}],
 			'unicorn/import-style': ['error', {
 				styles: {
-					path: {
+					'lucide-react': {
 						unassigned: false,
 						default: false,
-						namespace: true,
+						namespace: false,
 						named: true
+					},
+					'react': {
+						unassigned: false,
+						default: false,
+						namespace: true,
+						named: false
+					},
+					'./styles.module.scss': {
+						unassigned: false,
+						default: false,
+						namespace: true,
+						named: false
 					}
 				}
 			}],

package/eslint/jest.mjs

@@ -48,6 +48,7 @@ export default [
 			 *
 			 * @see https://github.com/import-js/eslint-plugin-import
 			 */
+			'import/dynamic-import-chunkname': 'off',
 			'import/no-unassigned-import': 'error',
 
 			/**

package/eslint/react.mjs

@@ -44,6 +44,9 @@ export default [
 					'shouldComponentUpdate'
 				]
 			}],
+			'@typescript-eslint/no-empty-object-type': ['error', { // Empty interfaces for Component props should be allowed to make it directly visible, that a component has no props.
+				allowWithName: 'Props$'
+			}],
 
 			/**
 			 * eslint-plugin-jsx-a11y

package/eslint/rules/enforce-logical-expression-parens.mjs

@@ -13,7 +13,7 @@ export default {
 		docs: {
 			description: 'Add parentheses around logical operations if not already present',
 			category: 'Best Practices',
-			recommended: false
+			recommended: true
 		},
 		fixable: 'code'
 	},
@@ -25,12 +25,21 @@ export default {
 					return; // Do not add parentheses if they are already present
 				}
 
-				// If no parentheses are present, add parentheses around the logical operation
 				context.report({
 					node,
 					message: 'Add parentheses around the logical operation.',
 					fix (fixer) {
-						return fixer.replaceText(node, `(${context.getSourceCode().getText(node)})`);
+						const nodeBefore = context.sourceCode.getTokenBefore(node, { includeComments: true });
+						const nodeAfter = context.sourceCode.getTokenAfter(node, { includeComments: true });
+
+						if (!nodeBefore || !nodeAfter || nodeBefore.loc?.end.line === node.loc?.start.line) {
+							return fixer.replaceText(node, `(${context.sourceCode.getText(node)})`);
+						}
+
+						return [
+							fixer.insertTextAfter(nodeBefore, '('),
+							fixer.insertTextBefore(nodeAfter, ')')
+						];
 					}
 				});
 			}

package/eslint/rules/enforce-ternary-parens.mjs

@@ -14,7 +14,7 @@ export default {
 		docs: {
 			description: 'Requires ternary expressions to be wrapped in parentheses.',
 			category: 'Styling',
-			recommended: false
+			recommended: true
 		}
 	},
 
@@ -29,8 +29,17 @@ export default {
 					node,
 					message: 'Ternary expressions must be wrapped in parentheses.',
 					fix (fixer) {
-						// Wrap the entire ternary expression in parentheses.
-						return fixer.replaceText(node, `(${context.sourceCode.getText(node)})`);
+						const nodeBefore = context.sourceCode.getTokenBefore(node, { includeComments: true });
+						const nodeAfter = context.sourceCode.getTokenAfter(node, { includeComments: true });
+
+						if (!nodeBefore || !nodeAfter || nodeBefore.loc?.end.line === node.loc?.start.line) {
+							return fixer.replaceText(node, `(${context.sourceCode.getText(node)})`);
+						}
+
+						return [
+							fixer.insertTextAfter(nodeBefore, '('),
+							fixer.insertTextBefore(nodeAfter, ')')
+						];
 					}
 				});
 			}

package/eslint/rules/no-extra-spaces-in-generics.mjs

@@ -13,7 +13,7 @@ export default {
 		docs: {
 			description: "Disallow spaces after '<' and before '>' in TypeScript generics.",
 			category: 'Stylistic Issues',
-			recommended: false
+			recommended: true
 		},
 		fixable: 'whitespace',
 		schema: [],

package/lint.js

@@ -582,7 +582,6 @@ function getConfigValue (taskName, taskConfig, optionName) {
 		const specificConfig = linterBundleConfig[/** @type {keyof typeof linterBundleConfig} */(taskName)];
 
 		if (typeof specificConfig === 'object' && optionName in specificConfig) {
-			// eslint-disable-next-line jsdoc/no-undefined-types -- False positive "The type 'specificConfig' is undefined."
 			const configValue = specificConfig[/** @type {keyof typeof specificConfig} */(optionName)];
 
 			if (Array.isArray(configValue)) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "linter-bundle",
-	"version": "7.1.1",
+	"version": "7.2.0",
 	"type": "module",
 	"description": "Ready-to use bundle of linting tools, containing configurations for ESLint, stylelint and markdownlint.",
 	"keywords": [
@@ -45,13 +45,13 @@
 		"@stylistic/eslint-plugin-jsx": "4.2.0",
 		"eslint": "9.22.0",
 		"eslint-formatter-unix": "8.40.0",
-		"eslint-import-resolver-typescript": "3.9.0",
+		"eslint-import-resolver-typescript": "4.2.0",
 		"eslint-import-resolver-webpack": "0.13.10",
 		"eslint-plugin-eslint-comments": "3.2.0",
 		"eslint-plugin-functional": "9.0.1",
 		"eslint-plugin-import": "2.31.0",
 		"eslint-plugin-jest": "28.11.0",
-		"eslint-plugin-jsdoc": "50.6.6",
+		"eslint-plugin-jsdoc": "50.6.8",
 		"eslint-plugin-jsx-a11y": "6.10.2",
 		"eslint-plugin-n": "17.16.2",
 		"eslint-plugin-promise": "7.2.1",

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/at-rule-name-case/index.mjs

@@ -45,6 +45,12 @@ const rule = (primary, _secondary, context) => (root, result) => {
 			return;
 		}
 
+		if (context.fix) {
+			atRule.name = expectedName;
+
+			return;
+		}
+
 		report({
 			message: messages.expected(name, expectedName),
 			node: atRule,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/at-rule-semicolon-newline-after/index.mjs

@@ -63,14 +63,19 @@ const rule = (primary, _secondary, context) => {
 				source: rawNodeString(nodeToCheck),
 				index: -1,
 				err: (message) => {
-					report({
-						message,
-						node: atRule,
-						index: atRule.toString().length + 1,
-						endIndex: atRule.toString().length + 1,
-						result,
-						ruleName
-					});
+					if (context.fix) {
+						nodeToCheck.raws.before = context.newline + nodeToCheck.raws.before;
+					}
+					else {
+						report({
+							message,
+							node: atRule,
+							index: atRule.toString().length + 1,
+							endIndex: atRule.toString().length + 1,
+							result,
+							ruleName
+						});
+					}
 				}
 			});
 		});

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/block-closing-brace-empty-line-before/index.mjs

@@ -97,6 +97,21 @@ const rule = (primary, secondaryOptions, context) => (root, result) => {
 			return;
 		}
 
+		if (context.fix) {
+			const { newline } = context;
+
+			if (typeof newline !== 'string') { return; }
+
+			if (expectEmptyLineBefore) {
+				addEmptyLineAfter(statement, newline);
+			}
+			else {
+				removeEmptyLinesAfter(statement, newline);
+			}
+
+			return;
+		}
+
 		const message = expectEmptyLineBefore ? messages.expected : messages.rejected;
 
 		report({

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/block-closing-brace-newline-after/index.mjs

@@ -112,6 +112,29 @@ const rule = (primary, secondaryOptions, context) => {
 				index: -1,
 				lineCheckStr: blockString(statement),
 				err: (message) => {
+					if (context.fix) {
+						const nodeToCheckRaws = nodeToCheck.raws;
+
+						if (typeof nodeToCheckRaws.before !== 'string') { return; }
+
+						if (primary.startsWith('always')) {
+							const index = nodeToCheckRaws.before.search(/\r?\n/);
+
+							nodeToCheckRaws.before =
+								index >= 0 ?
+									nodeToCheckRaws.before.slice(index)
+									: context.newline + nodeToCheckRaws.before;
+
+							return;
+						}
+
+						if (primary.startsWith('never')) {
+							nodeToCheckRaws.before = '';
+
+							return;
+						}
+					}
+
 					report({
 						message,
 						node: statement,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/block-closing-brace-newline-before/index.mjs

@@ -86,6 +86,36 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 		 * @param {string} message
 		 */
 		function complain (message) {
+			if (context.fix) {
+				const statementRaws = statement.raws;
+
+				if (typeof statementRaws.after !== 'string') { return; }
+
+				if (primary.startsWith('always')) {
+					const firstWhitespaceIndex = statementRaws.after.search(/\s/);
+					const newlineBefore =
+							firstWhitespaceIndex >= 0 ?
+								statementRaws.after.slice(0, firstWhitespaceIndex)
+								: statementRaws.after;
+					const newlineAfter =
+							firstWhitespaceIndex >= 0 ? statementRaws.after.slice(firstWhitespaceIndex) : '';
+					const newlineIndex = newlineAfter.search(/\r?\n/);
+
+					statementRaws.after =
+							newlineIndex >= 0 ?
+								newlineBefore + newlineAfter.slice(newlineIndex)
+								: newlineBefore + context.newline + newlineAfter;
+
+					return;
+				}
+
+				if (primary === 'never-multi-line') {
+					statementRaws.after = statementRaws.after.replace(/\s/g, '');
+
+					return;
+				}
+			}
+
 			report({
 				message,
 				result,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/block-closing-brace-space-before/index.mjs

@@ -74,6 +74,24 @@ const rule = (primary, _secondaryOptions, context) => {
 				source,
 				index: source.length - 1,
 				err: (message) => {
+					if (context.fix) {
+						const statementRaws = statement.raws;
+
+						if (typeof statementRaws.after !== 'string') { return; }
+
+						if (primary.startsWith('always')) {
+							statementRaws.after = statementRaws.after.replace(/\s*$/, ' ');
+
+							return;
+						}
+
+						if (primary.startsWith('never')) {
+							statementRaws.after = statementRaws.after.replace(/\s*$/, '');
+
+							return;
+						}
+					}
+
 					report({
 						message,
 						node: statement,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/block-opening-brace-newline-after/index.mjs

@@ -108,6 +108,58 @@ const rule = (primary, secondaryOptions, context) => {
 				index: -1,
 				lineCheckStr: blockString(statement),
 				err: (m) => {
+					if (context.fix) {
+						const nodeToCheckRaws = nodeToCheck.raws;
+
+						if (typeof nodeToCheckRaws.before !== 'string') { return; }
+
+						if (primary.startsWith('always')) {
+							const index = nodeToCheckRaws.before.search(/\r?\n/);
+
+							nodeToCheckRaws.before =
+								index >= 0 ?
+									nodeToCheckRaws.before.slice(index)
+									: context.newline + nodeToCheckRaws.before;
+
+							backupCommentNextBefores.delete(nodeToCheck);
+
+							return;
+						}
+
+						if (primary === 'never-multi-line') {
+							// Restore the `before` of the node next to the comment node.
+							for (const [node, before] of backupCommentNextBefores.entries()) {
+								node.raws.before = before;
+							}
+
+							backupCommentNextBefores.clear();
+
+							// Fix
+							const reNewLine = /\r?\n/;
+							let fixTarget = statement.first;
+
+							while (fixTarget) {
+								const fixTargetRaws = fixTarget.raws;
+
+								if (typeof fixTargetRaws.before !== 'string') { continue; }
+
+								if (reNewLine.test(fixTargetRaws.before || '')) {
+									fixTargetRaws.before = fixTargetRaws.before.replace(/\r?\n/g, '');
+								}
+
+								if (fixTarget.type !== 'comment') {
+									break;
+								}
+
+								fixTarget = fixTarget.next();
+							}
+
+							nodeToCheckRaws.before = '';
+
+							return;
+						}
+					}
+
 					report({
 						message: m,
 						node: statement,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/block-opening-brace-space-after/index.mjs

@@ -81,6 +81,24 @@ const rule = (primary, secondaryOptions, context) => {
 				source: blockString(statement),
 				index: 0,
 				err: (m) => {
+					if (context.fix) {
+						const statementFirst = statement.first;
+
+						if (statementFirst == null) { return; }
+
+						if (primary.startsWith('always')) {
+							statementFirst.raws.before = ' ';
+
+							return;
+						}
+
+						if (primary.startsWith('never')) {
+							statementFirst.raws.before = '';
+
+							return;
+						}
+					}
+
 					report({
 						message: m,
 						node: statement,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/block-opening-brace-space-before/index.mjs

@@ -108,6 +108,20 @@ const rule = (primary, secondaryOptions, context) => {
 				index: source.length,
 				lineCheckStr: blockString(statement),
 				err: (m) => {
+					if (context.fix) {
+						if (primary.startsWith('always')) {
+							statement.raws.between = ' ';
+
+							return;
+						}
+
+						if (primary.startsWith('never')) {
+							statement.raws.between = '';
+
+							return;
+						}
+					}
+
 					report({
 						message: m,
 						node: statement,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/color-hex-case/index.mjs

@@ -53,6 +53,13 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 
 			if (value === expected) { return; }
 
+			if (context.fix) {
+				node.value = expected;
+				needsFix = true;
+
+				return;
+			}
+
 			report({
 				message: messages.expected(value, expected),
 				node: decl,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-bang-space-before/index.mjs

@@ -43,7 +43,7 @@ const rule = (primary, _secondaryOptions, context) => {
 			locationChecker: checker.before,
 			checkedRuleName: ruleName,
 			fix:
-				(decl, index) => {
+			context.fix ? (decl, index) => {
 					let bangIndex = index - declarationValueIndex(decl);
 					const value = getDeclarationValue(decl);
 					let target;
@@ -71,7 +71,6 @@ const rule = (primary, _secondaryOptions, context) => {
 					const targetAfter = target.slice(bangIndex);
 
 					if (primary === 'always') {
-
 						setFixed(targetBefore.replace(/\s*$/, '') + ' ' + targetAfter);
 
 						return true;
@@ -84,7 +83,7 @@ const rule = (primary, _secondaryOptions, context) => {
 					}
 
 					return false;
-				  }
+				  } : null
 		});
 	};
 };

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-semicolon-newline-after/index.mjs

@@ -71,6 +71,25 @@ const rule = (primary, _secondaryOptions, context) => {
 				index: -1,
 				lineCheckStr: blockString(parentRule),
 				err: (m) => {
+					if (context.fix) {
+						if (primary.startsWith('always')) {
+							const index = nodeToCheck.raws.before.search(/\r?\n/);
+
+							nodeToCheck.raws.before =
+								index >= 0 ?
+									nodeToCheck.raws.before.slice(index)
+									: context.newline + nodeToCheck.raws.before;
+
+							return;
+						}
+
+						if (primary === 'never-multi-line') {
+							nodeToCheck.raws.before = '';
+
+							return;
+						}
+					}
+
 					report({
 						message: m,
 						node: decl,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-semicolon-space-after/index.mjs

@@ -64,6 +64,20 @@ const rule = (primary, _secondaryOptions, context) => {
 				index: -1,
 				lineCheckStr: blockString(parentRule),
 				err: (m) => {
+					if (context.fix) {
+						if (primary.startsWith('always')) {
+							nextDecl.raws.before = ' ';
+
+							return;
+						}
+
+						if (primary.startsWith('never')) {
+							nextDecl.raws.before = '';
+
+							return;
+						}
+					}
+
 					report({
 						message: m,
 						node: decl,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-semicolon-space-before/index.mjs

@@ -61,6 +61,32 @@ const rule = (primary, _secondaryOptions, context) => {
 				index: declString.length,
 				lineCheckStr: blockString(parentRule),
 				err: (m) => {
+					if (context.fix) {
+						const value = getDeclarationValue(decl);
+
+						if (primary.startsWith('always')) {
+							if (decl.important) {
+								decl.raws.important = ' !important ';
+							}
+							else {
+								setDeclarationValue(decl, value.replace(/\s*$/, ' '));
+							}
+
+							return;
+						}
+
+						if (primary.startsWith('never')) {
+							if (decl.raws.important) {
+								decl.raws.important = decl.raws.important.replace(/\s*$/, '');
+							}
+							else {
+								setDeclarationValue(decl, value.replace(/\s*$/, ''));
+							}
+
+							return;
+						}
+					}
+
 					report({
 						message: m,
 						node: decl,

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declaration-block-trailing-semicolon/index.mjs

@@ -99,6 +99,18 @@ const rule = (primary, secondaryOptions, context) => (root, result) => {
 				return;
 			}
 
+			// auto-fix
+			if (context.fix) {
+				node.parent.raws.semicolon = true;
+
+				if (isAtRule(node)) {
+					node.raws.between = '';
+					node.parent.raws.after = ' ';
+				}
+
+				return;
+			}
+
 			message = messages.expected;
 		}
 		else if (primary === 'never') {
@@ -106,6 +118,13 @@ const rule = (primary, secondaryOptions, context) => (root, result) => {
 				return;
 			}
 
+			// auto-fix
+			if (context.fix) {
+				node.parent.raws.semicolon = false;
+
+				return;
+			}
+
 			message = messages.rejected;
 		}
 		else {