linter-bundle 7.0.0 → 7.1.1

package/.linter-bundle.js

@@ -18,11 +18,11 @@ export default {
 					'.git/**',
 					'.github/FUNDING.yml',
 					'.vscode/settings.json',
-					'eslint/rules/package.json',
 					`eslint/rules/${snippets.kebabCase}.{js,mjs,md}`,
+					`eslint/rules/helper/${snippets.kebabCase}.{js,mjs,md}`,
 					`eslint/${snippets.kebabCase}.mjs`,
 					'files/index.js',
-					`helper/${snippets.kebabCase}.{js,cjs,mjs,d.ts}`,
+					`helper/${snippets.kebabCase}.{js,mjs,cjs,d.ts}`,
 					'markdownlint/base.json',
 					'node_modules/**',
 					'stylelint/index.mjs',

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.0.0...HEAD)
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v7.1.1...HEAD)
+
+## [7.1.1] - 2025-03-15
+
+### Fixed
+
+- [eslint/react] Fixed `Key "plugins": Cannot redefine plugin "linter-bundle".` issue
+
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v7.1.0...v7.1.1)
+
+## [7.1.0] - 2025-03-15
+
+### Fixed
+
+- [eslint/jest] Fix code for Jest Version detection
+
+### Changed
+
+- [general] Suppress Node.js warnings, such as 'ExperimentalWarning: Importing JSON modules is an experimental feature and might change at any time' (which is triggered by ESLint)
+- [eslint] Added custom linter rule [`linter-bundle/enforce-logical-expression-parens`](./eslint/rules/enforce-logical-expression-parens.md) which enforces parentheses around logical operations
+- [eslint] Added custom linter rule [`linter-bundle/enforce-ternary-parens`](./eslint/rules/enforce-ternary-parens.md) which ensures ternary expressions are wrapped in parentheses
+- [eslint] Added custom linter rule [`linter-bundle/no-extra-spaces-in-generics`](./eslint/rules/no-extra-spaces-in-generics.md) to disallows spaces after the `<` and before the `>` in TypeScript generics
+- [eslint] Added custom linter rule [`linter-bundle/no-ternary-return`](./eslint/rules/no-ternary-return.md) which disallows ternary expressions as return values for better readability
+- [eslint] Configured [`padding-line-between-statements`](https://eslint.org/docs/latest/rules/padding-line-between-statements) to enforce line-breaks before `return`, `throw`, `break`, `continue`, around multi-line block statements and around `const`, `let`, `var` groups
+- [eslint/react] Added custom linter rule [`linter-bundle/ensure-lucide-import-consistency`](./eslint/rules/ensure-lucide-import-consistency.md) to enforces using [Lucide](https://lucide.dev/guide/packages/lucide-react) prefix for lucide-react imports and their usage
+- [eslint] Updated `eslint-import-resolver-typescript` from `3.8.4` to `3.9.0`
+- [stylelint] Updated `stylelint` from `16.15.0` to `16.16.0`
+
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v7.0.0...v7.1.0)
 
 ## [7.0.0] - 2025-03-11
 
@@ -145,6 +173,7 @@ Beside these changes:
 - [eslint] Make use of [`@typescript-eslint/prefer-promise-reject-errors`](https://typescript-eslint.io/rules/prefer-promise-reject-errors/) rule
 - [markdownlint] Make use of new [`MD054`/link-image-style](https://github.com/DavidAnson/markdownlint/blob/main/doc/md054.md) rule
 - [markdownlint] Make use of new [`MD056`/table-column-count](https://github.com/DavidAnson/markdownlint/blob/main/doc/md056.md) rule
+- [audit] Updated `improved-yarn-audit` from `3.0.0` to `3.0.3`
 
 ### Added
 

package/README.md

@@ -40,8 +40,13 @@ The `linter-bundle` is using the Flat Configuration Format which was introduced
 
 Beside that, the following additional rules are part of this bundle:
 
-- [linter-bundle/no-unnecessary-typeof](./eslint/rules/no-unnecessary-typeof.md)
-- [linter-bundle/restricted-filenames](./eslint/rules/restricted-filenames.md)
+- [`linter-bundle/enforce-logical-expression-parens`](./eslint/rules/enforce-logical-expression-parens.md)
+- [`linter-bundle/enforce-ternary-parens`](./eslint/rules/enforce-ternary-parens.md)
+- [`linter-bundle/ensure-lucide-import-consistency`](./eslint/rules/ensure-lucide-import-consistency.md)
+- [`linter-bundle/no-extra-spaces-in-generics`](./eslint/rules/no-extra-spaces-in-generics.md)
+- [`linter-bundle/no-ternary-return`](./eslint/rules/no-ternary-return.md)
+- [`linter-bundle/no-unnecessary-typeof`](./eslint/rules/no-unnecessary-typeof.md)
+- [`linter-bundle/restricted-filenames`](./eslint/rules/restricted-filenames.md)
 
 ### stylelint
 

package/eslint/index.mjs

@@ -22,6 +22,11 @@ import * as typescriptEslint from 'typescript-eslint';
 import * as ensureType from '../helper/ensure-type.mjs';
 import { linterBundleConfig } from '../helper/linter-bundle-config.js';
 
+import enforceLogicalExpressionParens from './rules/enforce-logical-expression-parens.mjs';
+import enforceTernaryParensRule from './rules/enforce-ternary-parens.mjs';
+import ensureLucideImportConsistencyRule from './rules/ensure-lucide-import-consistency.mjs';
+import noExtraSpacesInGenericsRule from './rules/no-extra-spaces-in-generics.mjs';
+import noTernaryReturnRule from './rules/no-ternary-return.mjs';
 import noUnnecessaryTypeofRule from './rules/no-unnecessary-typeof.mjs';
 import restrictedFilenamesRule from './rules/restricted-filenames.mjs';
 
@@ -47,6 +52,11 @@ export default [
 
 			'linter-bundle': {
 				rules: {
+					'enforce-logical-expression-parens': enforceLogicalExpressionParens,
+					'enforce-ternary-parens': enforceTernaryParensRule,
+					'ensure-lucide-import-consistency': ensureLucideImportConsistencyRule,
+					'no-extra-spaces-in-generics': noExtraSpacesInGenericsRule,
+					'no-ternary-return': noTernaryReturnRule,
 					'no-unnecessary-typeof': noUnnecessaryTypeofRule,
 					'restricted-filenames': restrictedFilenamesRule
 				}
@@ -133,6 +143,10 @@ export default [
 			/**
 			 * ./rules
 			 */
+			'linter-bundle/enforce-logical-expression-parens': 'error',
+			'linter-bundle/enforce-ternary-parens': 'error',
+			'linter-bundle/no-extra-spaces-in-generics': 'error',
+			'linter-bundle/no-ternary-return': 'error',
 			'linter-bundle/no-unnecessary-typeof': 'error',
 
 			/**
@@ -374,7 +388,14 @@ export default [
 			'operator-assignment': 'error',
 			'operator-linebreak': ['error', 'after', { overrides: { ':': 'ignore' } }],
 			'padded-blocks': ['error', 'never'],
-			'padding-line-between-statements': 'error',
+			'padding-line-between-statements': [
+				'error',
+				{ blankLine: 'always', prev: '*', next: ['return', 'throw', 'break', 'continue'] },
+				{ blankLine: 'always', prev: ['const', 'let', 'var'], next: '*' },
+				{ blankLine: 'any', prev: ['const', 'let', 'var'], next: ['const', 'let', 'var'] },
+				{ blankLine: 'always', prev: '*', next: 'multiline-block-like' },
+				{ blankLine: 'always', prev: 'multiline-block-like', next: '*' }
+			],
 			'prefer-arrow-callback': ['error', { allowNamedFunctions: true }],
 			'prefer-const': 'error',
 			'prefer-destructuring': 'off', // We don't prefer destructuring if a type is specified ['error', { VariableDeclarator: { array: true, object: true }, AssignmentExpression: { array: false, object: false } }],

package/eslint/jest.mjs

@@ -155,10 +155,13 @@ export default [
 async function getJestVersion () {
 	try {
 		const require = createRequire(import.meta.url);
+		const fileUrl = new URL('file:');
 
-		const jestModule = await import(require.resolve('jest', { paths: [process.cwd()] }));
+		fileUrl.pathname = require.resolve('jest', { paths: [process.cwd()] });
 
-		const version = jestModule.getVersion().split('.')[0];
+		const jestModule = await import(fileUrl.toString());
+		const jest = ('default' in jestModule ? jestModule.default : jestModule);
+		const version = jest.getVersion().split('.')[0];
 
 		process.stdout.write(`Detected Jest version: ${version}\n\n`);
 

package/eslint/react.mjs

@@ -20,6 +20,11 @@ export default [
 	{
 		files: ['**/*.tsx'],
 		rules: {
+			/**
+			 * ./rules
+			 */
+			'linter-bundle/ensure-lucide-import-consistency': 'error',
+
 			/**
 			 * typescript-eslint
 			 *

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

@@ -0,0 +1,31 @@
+# Enforce parentheses around logical operations (`linter-bundle/enforce-logical-expression-parens`)
+
+## Rule Details
+
+This rule ensures that logical operations (using `&&`, `||`, etc.) are always enclosed in parentheses unless they are already part of an existing expression. This improves readability and prevents potential issues with operator precedence.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+return foo !== null && foo.bar === 42 && baz === 84;
+```
+
+The logical operations in the above code are not enclosed in parentheses. The rule will automatically add parentheses to make the code clearer and ensure proper precedence.
+
+Corrected code would look like this:
+
+```ts
+return (foo !== null && foo.bar === 42 && baz === 84);
+```
+
+### When the rule will not apply
+
+If the logical operations are already inside parentheses, no changes will be made:
+
+```ts
+if (foo !== null && foo.bar === 42 && baz === 84) {
+  // code
+}
+```
+
+In this case, the code is already correctly wrapped in parentheses, so no further modifications are necessary.

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

@@ -0,0 +1,39 @@
+/**
+ * @file ESLint rule which ensures logical operations are wrapped in parentheses.
+ */
+
+import { isParenthesized } from './helper/is-parenthesized.mjs';
+
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export default {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Add parentheses around logical operations if not already present',
+			category: 'Best Practices',
+			recommended: false
+		},
+		fixable: 'code'
+	},
+	create (context) {
+		return {
+			LogicalExpression (node) {
+				// Check if the parent node is a logical expression
+				if (node.parent.type === 'LogicalExpression' || isParenthesized(context, node)) {
+					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)})`);
+					}
+				});
+			}
+		};
+	}
+};

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

@@ -0,0 +1,29 @@
+# Enforce parentheses around ternary expressions (`linter-bundle/enforce-ternary-parens`)
+
+## Rule Details
+
+This rule enforces that ternary expressions are always wrapped in parentheses to improve readability and maintain consistency in code formatting.
+
+### Examples of **incorrect** code for this rule
+
+```ts
+const foo = bar ? 1 : 2;
+const value = condition ? 'yes' : 'no';
+```
+
+### Examples of **correct** code for this rule
+
+```ts
+const foo = (bar ? 1 : 2);
+const value = (condition ? 'yes' : 'no');
+```
+
+## Why is this rule useful?
+
+- **Improved readability**: Wrapping ternary expressions in parentheses makes it clear that the entire expression is evaluated together.
+- **Consistency**: Ensures a uniform style when using the ternary operator.
+- **Avoids ambiguity**: Helps prevent misunderstandings in complex expressions.
+
+## Fixable
+
+This rule is fixable. It will automatically wrap ternary expressions in parentheses.

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

@@ -0,0 +1,39 @@
+/**
+ * @file ESLint rule which ensures ternary expressions are wrapped in parentheses.
+ */
+
+import { isParenthesized } from './helper/is-parenthesized.mjs';
+
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export default {
+	meta: {
+		type: 'problem',
+		fixable: 'code',
+		docs: {
+			description: 'Requires ternary expressions to be wrapped in parentheses.',
+			category: 'Styling',
+			recommended: false
+		}
+	},
+
+	create (context) {
+		return {
+			ConditionalExpression (node) {
+				if (isParenthesized(context, node)) {
+					return;
+				}
+
+				context.report({
+					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)})`);
+					}
+				});
+			}
+		};
+	}
+};

package/eslint/rules/ensure-lucide-import-consistency.md

@@ -0,0 +1,38 @@
+# Enforces using Lucide prefix for lucide-react imports and their usage (`linter-bundle/ensure-lucide-import-consistency`)
+
+## Rule Details
+
+This rule ensures that components imported from `lucide-react` are used with a `Lucide` prefix. It checks both the import statements and the JSX or JavaScript usage of these components.
+If a component does not follow this convention, it will be automatically fixed by replacing the component name with the properly prefixed name (`Lucide`).
+
+### Correct Usage
+
+When importing components from `lucide-react`, the component name should start with the `Lucide` prefix.
+
+#### Correct Code Example
+
+```ts
+import { LucideHome } from 'lucide-react';
+
+<LucideHome />
+```
+
+#### Incorrect Code Example
+
+```ts
+import { Home } from 'lucide-react';
+
+<Home />
+```
+
+### Rule Behavior
+
+- **Import Declarations**: If a component from `lucide-react` is imported without the `Lucide` prefix, the rule will automatically rename it to add the `Lucide` prefix.
+  
+- **JSX Usage**: In JSX, if a component is used without the `Lucide` prefix (even if correctly imported), it will be reported and fixed.
+
+- **JavaScript Usage**: For non-JSX usage (e.g., when components are referenced via `React.createElement` or directly as identifiers), the rule will also ensure the correct `Lucide` prefix is applied.
+
+## Fixable
+
+This rule is fixable. It will automatically rename components and their usages to ensure they follow the `Lucide` prefix convention.

package/eslint/rules/ensure-lucide-import-consistency.mjs

@@ -0,0 +1,112 @@
+/**
+ * @file ESLint rule which enforces using Lucide prefix for lucide-react imports and their usage.
+ */
+
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+/**
+ * @typedef {'alternative'} MessageIds
+ */
+
+/** @type {import('@typescript-eslint/utils/ts-eslint').RuleModule<MessageIds>} */
+export default {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforces using Lucide prefix for lucide-react imports and their usage',
+			category: 'Best Practices',
+			recommended: true
+		},
+		messages: {
+			alternative: 'Please use "{{lucideName}}" instead of "{{componentName}}"'
+		},
+		schema: [],
+		fixable: 'code'
+	},
+	defaultOptions: [],
+	create (context) {
+		// Track renamed imports from lucide-react
+		const renamedImports = new Map();
+
+		return {
+			ImportDeclaration (node) {
+				if (node.source.value === 'lucide-react') {
+					for (const specifier of node.specifiers) {
+						if (specifier.type === AST_NODE_TYPES.ImportSpecifier) {
+							const importedName = /** @type {any} */(specifier.imported).name;
+							const localName = specifier.local.name;
+
+							if (!importedName.startsWith('Lucide')) {
+								const lucideName = `Lucide${importedName.replace(/Icon$/u, '')}`;
+
+								// Store the mapping of local name to Lucide name
+								renamedImports.set(localName, lucideName);
+
+								context.report({
+									node: specifier,
+									messageId: 'alternative',
+									data: { lucideName, importedName },
+									fix (fixer) {
+										return fixer.replaceText(
+											specifier.imported,
+											lucideName
+										);
+									}
+								});
+							}
+						}
+					}
+				}
+			},
+
+			// Fix JSX usage
+			JSXIdentifier (node) {
+				// Only check opening elements, not attributes
+				if (node.parent.type === AST_NODE_TYPES.JSXOpeningElement || node.parent.type === AST_NODE_TYPES.JSXClosingElement) {
+					const componentName = node.name;
+
+					if (renamedImports.has(componentName)) {
+						/** @type {string} */
+						const lucideName = renamedImports.get(componentName);
+
+						context.report({
+							node,
+							messageId: 'alternative',
+							data: { lucideName, componentName },
+							fix (fixer) {
+								return fixer.replaceText(node, lucideName);
+							}
+						});
+					}
+				}
+			},
+
+			// Fix JS usage (for non-JSX cases like React.createElement)
+			Identifier (node) {
+				// Exclude import declarations (already handled) and JSX (handled separately)
+				if (
+					node.parent.type !== AST_NODE_TYPES.ImportSpecifier &&
+					node.parent.type !== AST_NODE_TYPES.JSXIdentifier &&
+					node.parent.type !== AST_NODE_TYPES.JSXOpeningElement &&
+					node.parent.type !== AST_NODE_TYPES.JSXClosingElement
+				) {
+					const componentName = node.name;
+
+					if (renamedImports.has(componentName)) {
+						/** @type {string} */
+						const lucideName = renamedImports.get(componentName);
+
+						context.report({
+							node,
+							messageId: 'alternative',
+							data: { lucideName, componentName },
+							fix (fixer) {
+								return fixer.replaceText(node, lucideName);
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};

package/eslint/rules/helper/is-parenthesized.mjs

@@ -0,0 +1,40 @@
+/**
+ * @file ESLint helper function to check if an ESLint Rule Node is wrapped in parentheses.
+ */
+
+/**
+ * Helper function to check if the node is wrapped in parentheses.
+ *
+ * @param {import('eslint').Rule.RuleContext} context - The rule context.
+ * @param {import('eslint').Rule.Node} node - The expression node.
+ * @returns {boolean} Returns `true` with the node is wrapped by parens.
+ */
+export function isParenthesized (context, node) {
+	const { sourceCode } = context;
+
+	const firstToken = sourceCode.getFirstToken(node);
+
+	if (!firstToken) {
+		return false;
+	}
+
+	const lastToken = sourceCode.getLastToken(node);
+
+	if (!lastToken) {
+		return false;
+	}
+
+	const tokenBefore = sourceCode.getTokenBefore(firstToken);
+
+	if (!tokenBefore) {
+		return false;
+	}
+
+	const tokenAfter = sourceCode.getTokenAfter(lastToken);
+
+	if (!tokenAfter) {
+		return false;
+	}
+
+	return (tokenBefore.value === '(' && tokenAfter.value === ')');
+}

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

@@ -0,0 +1,25 @@
+# Disallow spaces in TypeScript generics (`linter-bundle/no-spaces-in-generics`)
+
+## Rule Details
+
+This rule disallows spaces after the `<` and before the `>` in TypeScript generics. Ensuring that no unnecessary spaces are used around generics helps maintain consistency and readability in your code.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+declare function foo< T>(x: T): T;  // Space after '<'
+
+function bar<U >(): U {             // Space before '>'
+    return null as U;
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+declare function foo<T>(x: T): T;
+
+function bar<U>(): U {
+    return null as U;
+}
+```

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

@@ -0,0 +1,55 @@
+/**
+ * @file ESLint rule which disallows spaces after '<' and before '>' in TypeScript generics.
+ */
+
+/**
+ * @typedef {'noSpaceAfterLessThan' | 'noSpaceBeforeGreaterThan'} MessageIds
+ */
+
+/** @type {import('@typescript-eslint/utils/ts-eslint').RuleModule<MessageIds>} */
+export default {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: "Disallow spaces after '<' and before '>' in TypeScript generics.",
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'whitespace',
+		schema: [],
+		messages: {
+			noSpaceAfterLessThan: "No space allowed after '<' in generics.",
+			noSpaceBeforeGreaterThan: "No space allowed before '>' in generics."
+		}
+	},
+	defaultOptions: [],
+	create (context) {
+		return {
+			TSTypeParameterInstantiation (node) {
+				const text = context.sourceCode.getText(node);
+
+				// Check for space after "<"
+				if ((/<[ \t]+/u).test(text)) {
+					context.report({
+						node,
+						messageId: 'noSpaceAfterLessThan',
+						fix (fixer) {
+							return fixer.replaceText(node, text.replace(/<[ \t]+/u, '<'));
+						}
+					});
+				}
+
+				// Check for space before ">"
+				if ((/[ \t]+>/u).test(text)) {
+					context.report({
+						node,
+						messageId: 'noSpaceBeforeGreaterThan',
+						fix (fixer) {
+							return fixer.replaceText(node, text.replace(/[ \t]+>/u, '>'));
+						}
+					});
+				}
+			}
+		};
+	}
+};

package/eslint/rules/no-ternary-return.md

@@ -0,0 +1,29 @@
+# Disallow ternary expressions as return values (`linter-bundle/no-ternary-return`)
+
+## Rule Details
+
+To improve code readability, this rule disallows using ternary expressions directly as return values. Instead, it enforces using explicit `if` statements.
+
+### Examples of **incorrect** code for this rule
+
+```ts
+function getValue(condition: boolean) {
+  return condition ? "yes" : "no";
+}
+```
+
+### Examples of **correct** code for this rule
+
+```ts
+function getValue(condition: boolean) {
+  if (condition) { 
+    return "yes";
+  } 
+  
+  return "no"; 
+}
+```
+
+## Fixable
+
+This rule is **fixable**. The autofix will transform ternary return expressions into an `if` statement followed by a separate `return`.

package/eslint/rules/no-ternary-return.mjs

@@ -0,0 +1,50 @@
+/**
+ * @file ESLint rule which disallows ternary expressions as return values for better readability.
+ */
+
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export default {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow ternary expressions as return values for better readability',
+			category: 'Stylistic Issues',
+			recommended: true
+		},
+		fixable: 'code',
+		schema: []
+	},
+	create (context) {
+		return {
+			ReturnStatement (node) {
+				if (node.argument && node.argument.type === 'ConditionalExpression') {
+					context.report({
+						node,
+						message: 'Avoid using ternary expressions as return values; use an if-else statement instead.',
+						fix (fixer) {
+							const sourceCode = context.sourceCode;
+							const argumentText = /** @type {any} */(node.argument)?.test;
+							const argumentConsequent = /** @type {any} */(node.argument)?.consequent;
+							const argumentAlternate = /** @type {any} */(node.argument)?.alternate;
+
+							if (!argumentText || !argumentConsequent || !argumentAlternate) {
+								return null;
+							}
+
+							const test = sourceCode.getText(argumentText);
+							const consequent = sourceCode.getText(argumentConsequent);
+							const alternate = sourceCode.getText(argumentAlternate);
+							const indent = (/^\s*/u).exec(sourceCode.getText(node))?.[0];
+
+							const fixedCode = `if (${test}) {\n${indent}  return ${consequent};\n}\n\n${indent}return ${alternate};`;
+
+							return fixer.replaceText(node, fixedCode);
+						}
+					});
+				}
+			}
+		};
+	}
+};

package/eslint/rules/no-unnecessary-typeof.mjs

@@ -8,6 +8,11 @@ import * as ts from 'typescript';
 
 import { ESLintUtils } from '@typescript-eslint/utils';
 
+/**
+ * @typedef {'text'} MessageIds
+ */
+
+/** @type {import('@typescript-eslint/utils/ts-eslint').RuleModule<MessageIds>} */
 export default {
 	meta: {
 		type: 'problem',
@@ -18,23 +23,13 @@ export default {
 		},
 		messages: {
 			text: 'Unnecessary `typeof`, because the only possible type of {{ variableName }} is `{{ typeName }}`.'
-		}
+		},
+		schema: []
 	},
+	defaultOptions: [],
 
-	/**
-	 * Create a new rule.
-	 *
-	 * @param {import('@typescript-eslint/utils/ts-eslint').RuleContext<any, any>} context - RuleContext of @typescript-eslint instead of ESlint
-	 * @returns {import('@typescript-eslint/utils/ts-eslint').RuleListener} RuleListener of @typescript-eslint, instead of ESlint
-	 */
 	create (context) {
 		return {
-			/**
-			 * Rule function to handle unary expressions.
-			 *
-			 * @param {import('@typescript-eslint/typescript-estree').TSESTree.UnaryExpression} node - UnaryExpression of @typescript-eslint instead of ESlint
-			 * @returns {import('@typescript-eslint/utils/ts-eslint').RuleFunction<import('@typescript-eslint/typescript-estree').TSESTree.UnaryExpression> | void} RuleFunction of @typescript-eslint instead of ESlint
-			 */
 			UnaryExpression (node) {
 				if (node.operator !== 'typeof') {
 					return;

package/eslint/rules/restricted-filenames.mjs

@@ -9,7 +9,6 @@ import micromatch from 'micromatch';
 // eslint-disable-next-line n/no-process-env -- If the ESLint sub-process is running from within the linter-bundle, we make use of its configuration.
 const isInLinterBundle = !process.env['LINTER_BUNDLE'];
 
-// eslint-disable-next-line n/no-unpublished-import -- @todo Is that a false-positive?
 const { linterBundleConfig } = (isInLinterBundle ? await import('../../helper/linter-bundle-config.js') : {});
 
 /**
@@ -56,7 +55,7 @@ export default {
 	create: (context) => {
 		const filePath = context.filename;
 		/** @type {{ basePath: string, allowed?: string[]; disallowed?: string[]; }[]} */
-		const options = linterBundleConfig?.files?.restrictions ? [...linterBundleConfig.files.restrictions, ...context.options] : context.options;
+		const options = (linterBundleConfig?.files?.restrictions ? [...linterBundleConfig.files.restrictions, ...context.options] : context.options);
 
 		for (const { basePath, allowed, disallowed } of options) {
 			const normalizedName = path.relative(path.join(process.cwd(), basePath), filePath);

package/helper/ensure-type.mjs

@@ -13,6 +13,11 @@
  * @returns {T extends Array<any> ? T : []} Either the input array, or an empty array, if the input array is not an array
  */
 export function array (value) {
+	if (Array.isArray(value)) {
+		// @ts-expect-error -- Right now the type definition of `Array.isArray()` is incorrect since it uses `arg is any[]` instead of the correct type of `arg`.
+		return value;
+	}
+
 	// @ts-expect-error -- Right now the type definition of `Array.isArray()` is incorrect since it uses `arg is any[]` instead of the correct type of `arg`.
-	return (Array.isArray(value) ? value : []);
+	return [];
 }

package/helper/get-git-files.js

@@ -41,7 +41,7 @@ export async function getGitFiles () {
 		gitFiles = [
 			...gitProcessResult.diff.stdout.trim().split('\0'),
 			...gitProcessResult.modified.stdout.trim().split('\0')
-		].filter((file, index, self) => !deletedFiles.includes(file) && self.indexOf(file) === index);
+		].filter((file, index, self) => (!deletedFiles.includes(file) && self.indexOf(file) === index));
 	}
 
 	return gitFiles;

package/helper/run-process.js

@@ -31,9 +31,11 @@ export async function runProcess (command, options) {
 				// eslint-disable-next-line n/no-process-env -- Pass all environment variables to the child process
 				...process.env,
 				...options?.env,
-				LINTER_BUNDLE: '1'
+				LINTER_BUNDLE: '1',
+				FORCE_COLOR: 'true',
+				NODE_NO_WARNINGS: '1'
 			},
-			shell: os.userInfo().shell ?? undefined
+			shell: (os.userInfo().shell ?? undefined)
 		});
 
 		lintingProcess.stdout?.on('data', (/** @type {string} */data) => {
@@ -45,7 +47,7 @@ export async function runProcess (command, options) {
 		});
 
 		lintingProcess.on('exit', (code) => resolve({
-			code: code ?? 0,
+			code: (code ?? 0),
 			stdout: stdout.join(''),
 			stderr: stderr.join(''),
 			runtime: performance.now() - startTimestamp

package/lint.js

@@ -319,7 +319,7 @@ async function runAuditTask (taskName, taskConfig) {
 					'--',
 					'better-npm-audit@3.11.0',
 					'audit',
-					`-l ${newTaskConfig.minSeverity?.[0] ?? 'moderate'}`,
+					`-l ${(newTaskConfig.minSeverity?.[0] ?? 'moderate')}`,
 					'-p',
 					newTaskConfig.exclude?.map((exclude) => `-i ${exclude}`).join(' ')
 				].filter((argument) => Boolean(argument)).join(' ')
@@ -333,8 +333,8 @@ async function runAuditTask (taskName, taskConfig) {
 					'npx',
 					'--yes',
 					'--',
-					'improved-yarn-audit@3.0.0',
-					`--min-severity ${newTaskConfig.minSeverity?.[0] ?? 'moderate'}`,
+					'improved-yarn-audit@3.0.3',
+					`--min-severity ${(newTaskConfig.minSeverity?.[0] ?? 'moderate')}`,
 					'--fail-on-missing-exclusions',
 					'--ignore-dev-deps',
 					newTaskConfig.exclude?.map((exclude) => `--exclude ${exclude}`).join(' ')
@@ -378,7 +378,7 @@ async function validateEnvironment () {
 	}
 
 	const outdatedDependencies = await getOutdatedDependencies();
-	const missingOverrides = outdatedDependencies.filter(({ name }) => !(npmOrYarn === 'npm' && outdatedOverrides.overrides.some((override) => name === override.name)) && !(npmOrYarn === 'yarn' && outdatedOverrides.resolutions.some((override) => name === override.name)));
+	const missingOverrides = outdatedDependencies.filter(({ name }) => (!(npmOrYarn === 'npm' && outdatedOverrides.overrides.some((override) => name === override.name)) && !(npmOrYarn === 'yarn' && outdatedOverrides.resolutions.some((override) => name === override.name))));
 
 	if (missingOverrides.length > 0) {
 		let installCommand;
@@ -393,9 +393,9 @@ async function validateEnvironment () {
 			propertyName = 'overrides';
 		}
 
-		process.stderr.write(`The installed version of ${missingOverrides.length === 1 ? 'one dependency' : `${missingOverrides.length} dependencies`} does not match to the version required by the linter-bundle:\n`);
+		process.stderr.write(`The installed version of ${(missingOverrides.length === 1 ? 'one dependency' : `${missingOverrides.length} dependencies`)} does not match to the version required by the linter-bundle:\n`);
 		process.stderr.write(`- ${missingOverrides.map((dependency) => `${dependency.name}: ${dependency.configuredVersion} is installed, but ${dependency.expectedVersion} is expected`).join('\n- ')}\n\n`);
-		process.stderr.write(`This could be caused by forgetting to execute \`${installCommand}\` after changing a version number in the package.json, or by some other package shipping outdated versions of the ${missingOverrides.length === 1 ? 'dependency' : 'dependencies'}.\n`);
+		process.stderr.write(`This could be caused by forgetting to execute \`${installCommand}\` after changing a version number in the package.json, or by some other package shipping outdated versions of the ${(missingOverrides.length === 1 ? 'dependency' : 'dependencies')}.\n`);
 		process.stderr.write('If another package is causing this problem, you can fix it by adding the following entry to your package.json:\n');
 		process.stderr.write(`{\n  "${propertyName}": {\n    ${missingOverrides.map((dependency) => `"${dependency.name}": "${dependency.expectedVersion}"`).join(',\n    ')}\n  }\n}\n\n`);
 
@@ -477,7 +477,7 @@ function getTasksToRun (argv) {
 async function getIncludes (taskConfig, pattern) {
 	const include = taskConfig['include'];
 
-	let includedFiles = (Array.isArray(include) && include.length > 0 ? /** @type {string[]} */(include.filter((item) => typeof item === 'string')) : undefined);
+	let includedFiles = ((Array.isArray(include) && include.length > 0) ? /** @type {string[]} */(include.filter((item) => typeof item === 'string')) : undefined);
 
 	if (taskConfig['git']?.[0]) {
 		const gitFiles = await getGitFiles();
@@ -498,7 +498,11 @@ async function getIncludes (taskConfig, pattern) {
 	}
 
 	if (!includedFiles) {
-		return (pattern ? `"${pattern}"` : '');
+		if (pattern) {
+			return `"${pattern}"`;
+		}
+
+		return '';
 	}
 
 	return `"${includedFiles.join('" "')}"`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "linter-bundle",
-	"version": "7.0.0",
+	"version": "7.1.1",
 	"type": "module",
 	"description": "Ready-to use bundle of linting tools, containing configurations for ESLint, stylelint and markdownlint.",
 	"keywords": [
@@ -45,7 +45,7 @@
 		"@stylistic/eslint-plugin-jsx": "4.2.0",
 		"eslint": "9.22.0",
 		"eslint-formatter-unix": "8.40.0",
-		"eslint-import-resolver-typescript": "3.8.4",
+		"eslint-import-resolver-typescript": "3.9.0",
 		"eslint-import-resolver-webpack": "0.13.10",
 		"eslint-plugin-eslint-comments": "3.2.0",
 		"eslint-plugin-functional": "9.0.1",
@@ -62,7 +62,7 @@
 		"markdownlint-cli": "0.44.0",
 		"micromatch": "4.0.8",
 		"postcss-scss": "4.0.9",
-		"stylelint": "16.15.0",
+		"stylelint": "16.16.0",
 		"stylelint-declaration-block-no-ignored-properties": "2.8.0",
 		"stylelint-high-performance-animation": "1.11.0",
 		"stylelint-order": "6.0.4",
@@ -71,6 +71,7 @@
 		"typescript-eslint": "8.26.1"
 	},
 	"peerDependencies": {
+		"@typescript-eslint/utils": "*",
 		"postcss-value-parser": "*",
 		"typescript": ">=4.0.0"
 	},

package/eslint/rules/package.json

@@ -1,8 +0,0 @@
-{
-	"type": "commonjs",
-	"peerDependencies": {
-		"@typescript-eslint/utils": "*",
-		"micromatch": "*",
-		"typescript": "*"
-	}
-}