linter-bundle 4.0.3 → 5.0.0

package/.linter-bundle.js

@@ -8,7 +8,7 @@ const snippets = {
 	pascalCase: '[A-Z]*([a-zA-Z0-9])'
 };
 
-module.exports = {
+export default {
 	files: {
 		restrictions: [
 			{
@@ -17,16 +17,17 @@ module.exports = {
 					'.git/**',
 					'.github/FUNDING.yml',
 					'.vscode/settings.json',
+					`eslint/rules/package.json`,
 					`eslint/rules/${snippets.kebabCase}.{js,md}`,
-					`eslint/{index.js,overrides-${snippets.kebabCase}.js}`,
+					`eslint/{index.cjs,overrides-${snippets.kebabCase}.cjs}`,
 					'files/index.js',
-					`helper/${snippets.kebabCase}.js`,
+					`helper/${snippets.kebabCase}.{js,cjs,d.ts}`,
 					'markdownlint/base.json',
 					'node_modules/**',
-					'stylelint/index.js',
+					'stylelint/index.cjs',
 					`stylelint/plugins/stylelint-${snippets.kebabCase}.js`,
 					'.editorconfig',
-					'.eslintrc.js',
+					'.eslintrc.cjs',
 					'.gitattributes',
 					'.gitignore',
 					'.linter-bundle.js',
@@ -37,10 +38,9 @@ module.exports = {
 					'lint.js',
 					'package-lock.json',
 					'package.json',
-					'stylelint.config.js',
+					'stylelint.config.cjs',
+					'test-stylelint.js',
 					'tsconfig.json',
-					'types.d.ts',
-					'validate-stylelint-options.mjs',
 					'vscode-eslint-1.png',
 					'vscode-eslint-2.png'
 				]

package/CHANGELOG.md

@@ -6,7 +6,21 @@ 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/v4.0.3...HEAD)
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v5.0.0...HEAD)
+
+## [5.0.0] - 2023-09-03
+
+## Changed
+
+- [general] Migrated the code base from CommonJS to ESModules (as far as possible, because ESLint currently does not support ESModules)
+- [general] The linter-bundle configuration can now be a ESModule (`.linter-bundle.mjs` is supported)
+- [files] Report unmatched `allowed` pattern
+- [markdownlint] Updated `markdownlint-cli` from `0.35.0` to `0.36.0`
+- [eslint] Disabled `considerComments` option of [`import/new-after-import`](https://github.com/import-js/eslint-plugin-import/blob/v2.28.1/docs/rules/newline-after-import.md) rule
+  as it conflicts with the [`import/order`](https://github.com/import-js/eslint-plugin-import/blob/v2.28.1/docs/rules/order.md) rule
+- [eslint/overrides-javascript] Disable [`import/dynamic-import-chunkname`](https://github.com/import-js/eslint-plugin-import/blob/v2.28.1/docs/rules/dynamic-import-chunkname.md) for JavaScript files
+
+[Show all code changes](https://github.com/jens-duttke/linter-bundle/compare/v4.0.3...v5.0.0)
 
 ## [4.0.3] - 2023-08-31
 

package/README.md

@@ -622,7 +622,7 @@ This can be done by adding these options to your `.vscode/settings.json`:
 {
   "eslint.nodePath": "./node_modules/linter-bundle/node_modules/eslint",
   "eslint.options": {
-    "overrideConfigFile": "./.eslintrc.js",
+    "overrideConfigFile": "./.eslintrc.js", // or "./.eslintrc.cjs" or "./eslintrc.json"
     "resolvePluginsRelativeTo": "./node_modules/linter-bundle",
     "rulePaths": ["./node_modules/linter-bundle/eslint/rules"],
     "reportUnusedDisableDirectives": "error",

package/eslint/{index.js → index.cjs}

@@ -8,8 +8,8 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const config = require('../helper/config.js');
-const ensureType = require('../helper/ensure-type');
+const ensureType = require('../helper/ensure-type.cjs');
+const { linterBundleConfig } = require('../helper/linter-bundle-config.cjs');
 
 module.exports = {
 	ignorePatterns: [
@@ -283,16 +283,16 @@ module.exports = {
 						name: 'isNaN',
 						message: 'Use Number.isNaN() instead, and ensure that the input value is of type number. isNaN(undefined) !== Number.isNaN(undefined)'
 					},
-					...ensureType.array(config.ts?.overrides?.general?.['no-restricted-globals']?.additionalRestrictions)
+					...ensureType.array(linterBundleConfig.ts?.overrides?.general?.['no-restricted-globals']?.additionalRestrictions)
 				],
 				'no-restricted-imports': 'off', // Covered by @typescript-eslint/no-restricted-imports
 				'no-restricted-properties': [
 					'error',
-					...ensureType.array(config.ts?.overrides?.general?.['no-restricted-properties']?.additionalRestrictions)
+					...ensureType.array(linterBundleConfig.ts?.overrides?.general?.['no-restricted-properties']?.additionalRestrictions)
 				],
 				'no-restricted-syntax': [
 					'error',
-					...ensureType.array(config.ts?.overrides?.general?.['no-restricted-syntax']?.additionalRestrictions)
+					...ensureType.array(linterBundleConfig.ts?.overrides?.general?.['no-restricted-syntax']?.additionalRestrictions)
 				],
 				'no-return-assign': 'error',
 				'no-script-url': 'error',
@@ -821,7 +821,7 @@ module.exports = {
 				'import/max-dependencies': ['error', { max: 20, ignoreTypeImports: true }],
 				'import/named': 'error',
 				'import/namespace': ['error', { allowComputed: true }],
-				'import/newline-after-import': ['error', { considerComments: true }],
+				'import/newline-after-import': ['error', { considerComments: false }],
 				'import/no-absolute-path': 'error',
 				'import/no-amd': 'error',
 				'import/no-anonymous-default-export': 'error',
@@ -866,7 +866,7 @@ module.exports = {
 					'newlines-between': 'always',
 					'pathGroupsExcludedImportTypes': [],
 					'pathGroups': [
-						...ensureType.array(config.ts?.overrides?.general?.['import/order']?.additionalExternalPatterns).map(
+						...ensureType.array(linterBundleConfig.ts?.overrides?.general?.['import/order']?.additionalExternalPatterns).map(
 							/**
 							 * Creates an "external" group using the additional external pattern configuration.
 							 * @param {string} pattern - A given pattern

package/eslint/{overrides-javascript-lazy.js → overrides-javascript-lazy.cjs}

@@ -2,7 +2,7 @@
  * @file Extends `./overrides-javascript` but ignores unsafe types.
  */
 
-const overridesJavaScript = require('./overrides-javascript');
+const overridesJavaScript = require('./overrides-javascript.cjs');
 
 module.exports = {
 	...overridesJavaScript,

package/eslint/{overrides-javascript.js → overrides-javascript.cjs}

@@ -43,6 +43,7 @@ module.exports = {
 				'import/no-import-module-exports': 'error',
 				'import/no-internal-modules': 'off',
 				'import/no-nodejs-modules': 'off',
+				'import/dynamic-import-chunkname': 'off',
 
 				/**
 				 * eslint-plugin-n

package/eslint/{overrides-react.js → overrides-react.cjs}

@@ -2,8 +2,8 @@
  * @file Settings for React code in TypeScript (TSX) files.
  */
 
-const config = require('../helper/config.js');
-const ensureType = require('../helper/ensure-type');
+const ensureType = require('../helper/ensure-type.cjs');
+const { linterBundleConfig } = require('../helper/linter-bundle-config.cjs');
 
 module.exports = {
 	overrides: [
@@ -91,11 +91,11 @@ module.exports = {
 				'react/forbid-component-props': ['error', { forbid: [
 					{
 						propName: 'className',
-						allowedFor: ensureType.array(config.ts?.overrides?.react?.['react/forbid-component-props']?.allowClassNameFor)
+						allowedFor: ensureType.array(linterBundleConfig.ts?.overrides?.react?.['react/forbid-component-props']?.allowClassNameFor)
 					},
 					{
 						propName: 'style',
-						allowedFor: ensureType.array(config.ts?.overrides?.react?.['react/forbid-component-props']?.allowStyleFor)
+						allowedFor: ensureType.array(linterBundleConfig.ts?.overrides?.react?.['react/forbid-component-props']?.allowStyleFor)
 					}
 				] }],
 				'react/forbid-dom-props': 'error',

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

@@ -6,7 +6,6 @@
 
 const ts = require('typescript');
 
-// @ts-expect-error -- TypeScript is not able to resolve the folder since @typescript-eslint v6.0.0
 const { ESLintUtils } = require('@typescript-eslint/utils');
 
 /**
@@ -22,8 +21,20 @@ module.exports = {
 			text: 'Unnecessary `typeof`, because the only possible type of {{ variableName }} is `{{ typeName }}`.'
 		}
 	},
+	/**
+	 * Create a new rule.
+	 *
+	 * @param {Readonly<import('@typescript-eslint/utils/ts-eslint').RuleContext<'text', []>>} 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/package.json

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

package/eslint/rules/restricted-filenames.js

@@ -6,7 +6,8 @@ const path = require('node:path');
 
 const micromatch = require('micromatch');
 
-const config = require('../../helper/config.js');
+// eslint-disable-next-line n/no-process-env -- Only merge the linter-bundle config, if the linting is not started by the linter-bundle CLI tool (e.g. if ESlint is running separately in VSCode), to get warnings shown there too
+const linterBundleConfig = (!process.env['LINTER_BUNDLE'] ? require('../../helper/linter-bundle-config.cjs').linterBundleConfig : undefined);
 
 /**
  * @type {import('eslint').Rule.RuleModule}
@@ -50,10 +51,9 @@ module.exports = {
 		}
 	},
 	create: (context) => {
-		const filePath = context.getFilename();
+		const filePath = context.filename;
 		/** @type {{ basePath: string, allowed?: string[]; disallowed?: string[]; }[]} */
-		// eslint-disable-next-line n/no-process-env -- Only merge the linter-bundle config, if the linting is not started by the linter-bundle CLI tool (e.g. if ESlint is running separately in VSCode), to get warnings shown there too
-		const options = (!process.env['LINTER_BUNDLE'] && config.files?.restrictions ? [...config.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/eslint/rules/restricted-filenames.md

@@ -64,7 +64,7 @@ If both are set, `disallowed` wins over `allowed` and all unspecified files are
 
 Instead of defining the same complex patterns over and over again, e.g. for casing, you can write them into a variable and use them within the pattern, for example by using template strings.
 
-Example of `.eslintrc.js`:
+Example of `.eslintrc.cjs`:
 
 ```js
 const snippets = {

package/files/index.js

@@ -2,17 +2,18 @@
  * @file Ensures that only files which match given glob patterns are part of the project.
  */
 
-const fs = require('node:fs');
-const path = require('node:path');
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
-const micromatch = require('micromatch');
+import micromatch from 'micromatch';
 
-const config = require('../helper/config.js');
+import { linterBundleConfig } from '../helper/linter-bundle-config.js';
 
-const restrictions = config.files?.restrictions;
+const restrictions = linterBundleConfig.files?.restrictions;
+const matcherOptions = { dot: true };
 
 if (Array.isArray(restrictions)) {
-	let noOfErrors = 0;
+	let noOfDisallowedFiles = 0;
 
 	const argFiles = process.argv.splice(2).map((filePath) => path.join(process.cwd(), filePath));
 
@@ -25,7 +26,24 @@ if (Array.isArray(restrictions)) {
 	const report = (filePath) => {
 		process.stderr.write(`Disallowed filename "${filePath}"\n`);
 
-		noOfErrors++;
+		noOfDisallowedFiles++;
+	};
+
+	/**
+	 * Reports the error to the `console` and increase the error counter.
+	 *
+	 * @param {[string, (str: string) => boolean][]} matchers - Array of micromatch matchers
+	 * @param {string} filePath - Path to the file to check
+	 * @returns {string | undefined} On match returns the matching pattern, otherwise `undefined`
+	 */
+	const isMatch = (matchers, filePath) => {
+		for (const [pattern, matcher] of matchers) {
+			if (matcher(filePath)) {
+				return pattern;
+			}
+		}
+
+		return;
 	};
 
 	for (const { basePath, allowed, disallowed } of restrictions) {
@@ -33,38 +51,50 @@ if (Array.isArray(restrictions)) {
 
 		const files = (argFiles.length > 0 ? argFiles.filter((filePath) => !path.relative(absoluteBasePath, filePath).startsWith('..')) : getFiles(absoluteBasePath));
 
+		const allowedMatchers = allowed?.map((pattern) => /** @type {[string, (str: string) => boolean]} */([pattern, micromatch.matcher(pattern, matcherOptions)]));
+		const disallowedMatchers = disallowed?.map((pattern) => /** @type {[string, (str: string) => boolean]} */([pattern, micromatch.matcher(pattern, matcherOptions)]));
+
+		const unmatchedAllowedPatterns = new Set(allowed);
+
 		for (const filePath of files) {
 			const normalizedFilePath = path.relative(absoluteBasePath, filePath);
 
-			if (allowed && !disallowed) {
-				if (!micromatch.isMatch(normalizedFilePath, allowed, { dot: true })) {
-					report(normalizedFilePath);
+			if (allowedMatchers && !disallowedMatchers) {
+				const pattern = isMatch(allowedMatchers, normalizedFilePath);
 
-					continue;
+				if (pattern) {
+					unmatchedAllowedPatterns.delete(pattern);
 				}
-			}
-			else if (!allowed && disallowed) {
-				if (micromatch.isMatch(normalizedFilePath, disallowed, { dot: true })) {
+				else {
 					report(normalizedFilePath);
-
-					continue;
 				}
 			}
-			else if (allowed && disallowed) {
-				if (
-					micromatch.isMatch(normalizedFilePath, disallowed, { dot: true }) ||
-					!micromatch.isMatch(normalizedFilePath, allowed, { dot: true })
-				) {
+			else if (!allowedMatchers && disallowedMatchers) {
+				if (isMatch(disallowedMatchers, normalizedFilePath)) {
 					report(normalizedFilePath);
+				}
+			}
+			else if (allowedMatchers && disallowedMatchers) {
+				const pattern = isMatch(allowedMatchers, normalizedFilePath);
 
-					continue;
+				if (pattern) {
+					unmatchedAllowedPatterns.delete(pattern);
 				}
+				else if (isMatch(disallowedMatchers, normalizedFilePath)) {
+					report(normalizedFilePath);
+				}
+			}
+		}
+
+		if (unmatchedAllowedPatterns.size > 0) {
+			for (const [pattern] of unmatchedAllowedPatterns.entries()) {
+				process.stderr.write(`Unmatched "allowed" pattern: "${pattern}"\n`);
 			}
 		}
 	}
 
-	if (noOfErrors > 0) {
-		process.stderr.write(`\nFound ${noOfErrors} disallowed file${(noOfErrors !== 0 ? 's' : '')}\n`);
+	if (noOfDisallowedFiles > 0) {
+		process.stderr.write(`\nFound ${noOfDisallowedFiles} disallowed file${(noOfDisallowedFiles !== 0 ? 's' : '')}\n`);
 
 		process.exitCode = -1;
 	}

package/helper/{ensure-type.js → ensure-type.cjs}

@@ -1,5 +1,7 @@
 /**
  * @file Ensures that a value is of a specific type, if not it converts the value into that type.
+ *
+ * This module has to be CommonJS as it is only used by `eslint` which does not support ESModules.
  */
 
 /**

package/helper/get-git-files.js

@@ -2,9 +2,9 @@
  * @file Handling of changed files from Git.
  */
 
-const { runProcess } = require('./run-process.js');
+import { runProcess } from './run-process.js';
 
-/** @typedef {import('./run-process').ProcessResult} ProcessResult */
+/** @typedef {import('./run-process.js').ProcessResult} ProcessResult */
 
 /** @type {{ diff: Promise<ProcessResult>; modified: Promise<ProcessResult>; deleted: Promise<ProcessResult>; } | undefined} */
 let gitFilesProcessPromise;
@@ -17,7 +17,7 @@ let gitFiles;
  * @public
  * @returns {Promise<string[]>} The list of changed files.
  */
-async function getGitFiles () {
+export async function getGitFiles () {
 	if (!gitFilesProcessPromise) {
 		gitFilesProcessPromise = {
 			// Returns changed files, also stashed and committed
@@ -46,7 +46,3 @@ async function getGitFiles () {
 
 	return gitFiles;
 }
-
-module.exports = {
-	getGitFiles
-};

package/helper/get-outdated-dependencies.js

@@ -0,0 +1,48 @@
+/**
+ * @file Ensures that the installed dependencies of the project matches to the versions used by the linter-bundle.
+ *
+ * @see https://docs.npmjs.com/cli/v8/configuring-npm/package-json#overrides
+ * @see https://classic.yarnpkg.com/en/docs/selective-version-resolutions/
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** @typedef {{ name: string; configuredVersion: string; expectedVersion: string; }} Dependency */
+
+/**
+ * Detects if installed versions of dependencies don't match to the required dependencies.
+ *
+ * @public
+ * @returns {Promise<Dependency[]>} An array of missing overrides (=wrong versions).
+ */
+export async function getOutdatedDependencies () {
+	const linterBundleDependencies = JSON.parse(await fs.readFile(path.resolve(dirname, '../package.json'), 'utf8')).dependencies;
+
+	const outdatedDependencies = await Promise.all(Object.entries(linterBundleDependencies).map(async ([name, expectedVersion]) => {
+		let dependencyPackageJson;
+
+		try {
+			dependencyPackageJson = JSON.parse(await fs.readFile(path.join(process.cwd(), 'node_modules', name, 'package.json'), 'utf8'));
+		}
+		catch {
+			// If the file does not exist, we ignore it, because in this case it's most likely a linter-bundle-only dependency.
+			return;
+		}
+
+		if (dependencyPackageJson.version !== expectedVersion) {
+			return {
+				name,
+				configuredVersion: dependencyPackageJson.version,
+				expectedVersion
+			};
+		}
+
+		return;
+	}));
+
+	return /** @type {Dependency[]} */(outdatedDependencies.filter((dependency) => dependency !== undefined));
+}

package/helper/{validate-package-overrides.js → get-outdated-overrides.js}

@@ -5,8 +5,11 @@
  * @see https://classic.yarnpkg.com/en/docs/selective-version-resolutions/
  */
 
-const fs = require('node:fs');
-const path = require('node:path');
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const dirname = path.dirname(fileURLToPath(import.meta.url));
 
 /** @typedef {{ name: string; configuredVersion: string; expectedVersion: string; }} Dependency */
 
@@ -14,11 +17,11 @@ const path = require('node:path');
  * Detects outdated "overrides"/"resolutions" dependencies.
  *
  * @public
- * @returns {{ overrides: Dependency[]; resolutions: Dependency[]; }} Either the input array, or an empty array, if the input array is not an array.
+ * @returns {Promise<{ overrides: Dependency[]; resolutions: Dependency[]; }>} Either the input array, or an empty array, if the input array is not an array.
  */
-function validatePackageOverrides () {
-	const linterBundleDependencies = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8')).dependencies;
-	const projectPackageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+export async function getOutdatedOverrides () {
+	const linterBundleDependencies = JSON.parse(await fs.readFile(path.resolve(dirname, '../package.json'), 'utf8')).dependencies;
+	const projectPackageJson = JSON.parse(await fs.readFile(path.join(process.cwd(), 'package.json'), 'utf8'));
 
 	const overrides = [];
 	const resolutions = [];
@@ -57,7 +60,3 @@ function validatePackageOverrides () {
 
 	return { overrides, resolutions };
 }
-
-module.exports = {
-	validatePackageOverrides
-};

package/helper/get-stylelint-path.js

@@ -2,31 +2,34 @@
  * @file Returns the path to the Stylelint CLI script.
  */
 
-const fs = require('node:fs');
-const path = require('node:path');
+import * as fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+
+const require = createRequire(import.meta.url);
 
 /**
  * Returns if the project is using npm or yarn.
  *
  * @public
- * @returns {string | null} Return the path to the Stylelint CLI script, or `null` if it can't be found.
+ * @returns {Promise<string | null>} Return the path to the Stylelint CLI script, or `null` if it can't be found.
  */
-function getStylelintPath () {
+export async function getStylelintPath () {
 	const stylelintLibPath = path.dirname(require.resolve('stylelint'));
 
-	for (const stylelintBinPath of [
+	for await (const stylelintBinPath of [
 		path.join(stylelintLibPath, '../bin/stylelint.mjs'),
 		path.join(stylelintLibPath, '../bin/stylelint.js')
 	]) {
-		if (fs.existsSync(stylelintBinPath)) {
-			return stylelintBinPath;
+		try {
+			const stat = await fs.stat(stylelintBinPath);
+
+			if (stat.isFile()) {
+				return stylelintBinPath;
+			}
 		}
+		catch { /* Do nothing */ }
 	}
 
 	return null;
 }
-
-module.exports = {
-	getStylelintPath
-};
-

package/helper/is-npm-or-yarn.js

@@ -2,30 +2,34 @@
  * @file Check if the project is using npm or yarn by checking the existence of a `package-lock.json` or a `yarn.lock`.
  */
 
-const fs = require('node:fs');
-const path = require('node:path');
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
 
 /**
  * Returns if the project is using npm or yarn.
  *
  * @public
- * @returns {'none' | 'npm' | 'yarn' | 'both'} Returns which package manager name.
+ * @returns {Promise<'none' | 'npm' | 'yarn' | 'both'>} Returns which package manager name.
  */
-function isNpmOrYarn () {
+export async function isNpmOrYarn () {
 	let npm = false;
 	let yarn = false;
 
 	try {
-		fs.accessSync(path.join(process.cwd(), 'package-lock.json'), fs.constants.R_OK);
+		const stat = await fs.stat(path.join(process.cwd(), 'package-lock.json'));
 
-		npm = true;
+		if (stat.isFile()) {
+			npm = true;
+		}
 	}
 	catch { /* `package-lock.json` cannot be accessed. */ }
 
 	try {
-		fs.accessSync(path.join(process.cwd(), 'yarn.lock'), fs.constants.R_OK);
+		const stat = await fs.stat(path.join(process.cwd(), 'yarn.lock'));
 
-		yarn = true;
+		if (stat.isFile()) {
+			yarn = true;
+		}
 	}
 	catch { /* `yarn.lock` cannot be accessed. */ }
 
@@ -43,7 +47,3 @@ function isNpmOrYarn () {
 
 	return 'none';
 }
-
-module.exports = {
-	isNpmOrYarn
-};

package/helper/linter-bundle-config.cjs

@@ -0,0 +1,70 @@
+/**
+ * @file CommonJS loader for `linter-bundle-config.js`.
+ *
+ * This module has to be CommonJS as it is only used by `eslint` which does not support ESModules.
+ *
+ * This workaround is necessary to load async ESModules in sync CommonJS code.
+ */
+
+const { Worker, isMainThread, parentPort } = require('node:worker_threads');
+
+if (isMainThread) {
+	const worker = new Worker(__filename);
+
+	const sizeSharedArrayBuffer = new SharedArrayBuffer(4);
+	const sizeInt32 = new Int32Array(sizeSharedArrayBuffer);
+
+	worker.postMessage({ sizeInt32 });
+
+	if (Atomics.wait(sizeInt32, 0, 0, 10_000) !== 'ok') {
+		throw new Error('No size received');
+	}
+
+	const dataSharedArrayBuffer = new SharedArrayBuffer((Math.ceil(sizeInt32[0] / 4) << 2));
+	const dataInt32 = new Int32Array(dataSharedArrayBuffer);
+
+	worker.postMessage({ dataInt32 });
+
+	if (Atomics.wait(dataInt32, 0, 0, 250) !== 'ok') {
+		throw new Error('No data received');
+	}
+
+	void worker.terminate();
+
+	const textDecoder = new TextDecoder('utf8');
+	const content = textDecoder.decode(new Uint8Array(dataSharedArrayBuffer).slice(0, sizeInt32[0]));
+
+	// @ts-expect-error TypeScript complains about the ESModule import, but correctly resolves it and applies the type.
+	/** @type {import('./linter-bundle-config.js')} */
+	module.exports = JSON.parse(content);
+}
+else {
+	/** @type {Uint8Array} */
+	let content;
+
+	/**
+	 * Handles requests from the main thread.
+	 *
+	 * @param {{ sizeInt32?: Int32Array; dataInt32?: Int32Array; }} data - Data received from the main thread
+	 * @returns {Promise<void>}
+	 */
+	const onData = async (data) => {
+		if (data.sizeInt32) {
+			const json = JSON.stringify(await import('./linter-bundle-config.js'));
+
+			const textEncoder = new TextEncoder();
+
+			content = textEncoder.encode(json);
+
+			Atomics.store(data.sizeInt32, 0, content.byteLength);
+			Atomics.notify(data.sizeInt32, 0);
+		}
+		else if (data.dataInt32) {
+			new Uint8Array(data.dataInt32.buffer).set(content);
+
+			Atomics.notify(data.dataInt32, 0);
+		}
+	};
+
+	parentPort?.on('message', onData);
+}