linter-bundle 4.0.3 → 5.0.1

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);
+}

package/helper/linter-bundle-config.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @file Type definition of `.linter-bundle.js` configuration.
+ */
+
+export interface LinterBundleConfig {
+	verbose?: boolean;
+	timing?: boolean;
+	git?: boolean;
+	tsc?: {
+		tsconfig?: string;
+	};
+	ts?: {
+		tsconfig?: string;
+		include?: string[];
+		exclude?: string[];
+		overrides?: {
+			/* eslint-disable @typescript-eslint/naming-convention -- `overrides` should match the original rule names */
+			general?: {
+				'no-restricted-globals'?: { additionalRestrictions?: { name: string; message: string; }[]; };
+				'no-restricted-properties'?: { additionalRestrictions?: { object: string; property: string; message: string; }[]; };
+				'no-restricted-syntax'?: { additionalRestrictions?: { selector: string; message: string; }[]; };
+				'import/order'?: { additionalExternalPatterns?: string[]; };
+			};
+			react?: {
+				'react/forbid-component-props'?: { allowClassNameFor?: string[]; allowStyleFor?: string[]; };
+			};
+			/* eslint-enable @typescript-eslint/naming-convention */
+		};
+	};
+	sass?: {
+		patternPrefix?: string;
+	};
+	audit?: {
+		minSeverity?: 'info' | 'low' | 'moderate' | 'high' | 'critical';
+		exclude?: string[];
+	};
+	files?: {
+		restrictions: {
+			basePath: string;
+			allowed?: string[];
+			disallowed?: string[];
+		}[];
+	};
+}
+
+export const linterBundleConfig: LinterBundleConfig;

package/helper/linter-bundle-config.js

@@ -0,0 +1,36 @@
+/**
+ * @file Returns the `.linter-bundle.js` configuration result.
+ */
+
+import * as path from 'node:path';
+
+export const linterBundleConfig = (
+	await loadConfig('.linter-bundle.json') ??
+	await loadConfig('.linter-bundle.cjs') ??
+	await loadConfig('.linter-bundle.mjs') ??
+	await loadConfig('.linter-bundle.js') ??
+	{}
+);
+
+/**
+ * Load a config file if it exist.
+ *
+ * @param {string} fileName - The name of the config file
+ * @returns {Promise<import('./linter-bundle-config.js').LinterBundleConfig | undefined>} - Either the file content for `undefined` if the file does not exist.
+ * */
+async function loadConfig (fileName) {
+	const filePath = path.join('file://', process.cwd(), fileName);
+
+	try {
+		const config = await import(filePath);
+
+		if ('default' in config) {
+			return config.default;
+		}
+
+		return config;
+	}
+	catch {
+		return;
+	}
+}

package/helper/run-process.js

@@ -2,10 +2,10 @@
  * @file Executes a process asynchronously.
  */
 
-/** @typedef {{ code: number; stdout: string; stderr: string; runtime: number; }} ProcessResult */
+import * as childProcess from 'node:child_process';
+import * as os from 'node:os';
 
-const childProcess = require('node:child_process');
-const os = require('node:os');
+/** @typedef {{ code: number; stdout: string; stderr: string; runtime: number; }} ProcessResult */
 
 /**
  * Executes a process asynchronously.
@@ -15,7 +15,7 @@ const os = require('node:os');
  * @param {childProcess.ExecOptions | undefined} [options] - The options of the `childProcess.exec()` method.
  * @returns {Promise<ProcessResult>} An object containing the result of the process execution
  */
-async function runProcess (command, options) {
+export async function runProcess (command, options) {
 	return new Promise((resolve) => {
 		const startTimestamp = performance.now();
 
@@ -25,8 +25,16 @@ async function runProcess (command, options) {
 		/** @type {string[]} */
 		const stderr = [];
 
-		// eslint-disable-next-line n/no-process-env -- We need to access `process.env`, because this is the default value if `env` is not set.
-		const lintingProcess = childProcess.exec(command, { ...options, env: { ...process.env, ...options?.env, LINTER_BUNDLE: '1' }, shell: os.userInfo().shell });
+		const lintingProcess = childProcess.exec(command, {
+			...options,
+			env: {
+				// eslint-disable-next-line n/no-process-env -- We need to access `process.env`, because this is the default value if `env` is not set.
+				...process.env,
+				...options?.env,
+				LINTER_BUNDLE: '1'
+			},
+			shell: os.userInfo().shell
+		});
 
 		lintingProcess.stdout?.on('data', (/** @type {string} */data) => {
 			stdout.push(data);
@@ -44,7 +52,3 @@ async function runProcess (command, options) {
 		}));
 	});
 }
-
-module.exports = {
-	runProcess
-};

package/lint.js

@@ -4,32 +4,37 @@
  * @file Entry point of the linter-bundle.
  */
 
-const path = require('node:path');
-const tty = require('node:tty');
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import * as tty from 'node:tty';
+import { fileURLToPath } from 'node:url';
 
-const micromatch = require('micromatch');
+import micromatch from 'micromatch';
 
-const config = require('./helper/config.js');
-const { findMissingOverrides } = require('./helper/find-missing-overrides.js');
-const { getGitFiles } = require('./helper/get-git-files.js');
-const { getStylelintPath } = require('./helper/get-stylelint-path.js');
-const { isNpmOrYarn } = require('./helper/is-npm-or-yarn.js');
-const { runProcess } = require('./helper/run-process.js');
-const { validatePackageOverrides } = require('./helper/validate-package-overrides.js');
+import { getGitFiles } from './helper/get-git-files.js';
+import { getOutdatedDependencies } from './helper/get-outdated-dependencies.js';
+import { getOutdatedOverrides } from './helper/get-outdated-overrides.js';
+import { getStylelintPath } from './helper/get-stylelint-path.js';
+import { isNpmOrYarn } from './helper/is-npm-or-yarn.js';
+import { linterBundleConfig } from './helper/linter-bundle-config.js';
+import { runProcess } from './helper/run-process.js';
+
+const require = createRequire(import.meta.url);
+const dirname = path.dirname(fileURLToPath(import.meta.url));
 
 /** @typedef {'files' | 'tsc' | 'ts' | 'sass' | 'md' | 'audit'} TaskNames */
 /** @typedef {Partial<Record<string, (string | boolean)[]>>} TaskConfig */
-/** @typedef {import('./helper/run-process').ProcessResult} ProcessResult */
+/** @typedef {import('./helper/run-process.js').ProcessResult} ProcessResult */
 /** @typedef {{ taskName: TaskNames; taskConfig: TaskConfig; }} TaskNameAndConfig */
 /** @typedef {TaskNameAndConfig & { command: string; options?: import('child_process').ExecOptions; }} TaskSetup */
 /** @typedef {{ jobTitle: string; taskSetup: TaskSetup; job: Promise<ProcessResult>; }} Job */
 
 const isTerminal = tty.isatty(1);
 
-const npmOrYarn = isNpmOrYarn();
+const npmOrYarn = await isNpmOrYarn();
 
-void (async () => {
-	if (!validateEnvironment()) {
+await (async () => {
+	if (!await validateEnvironment()) {
 		return;
 	}
 
@@ -135,7 +140,7 @@ async function runFilesTask (taskName, taskConfig) {
 	return runTask({
 		taskName,
 		taskConfig: newTaskConfig,
-		command: `node "${path.resolve(__dirname, './files/index.js')}" ${includes}`
+		command: `node "${path.resolve(dirname, './files/index.js')}" ${includes}`
 	});
 }
 
@@ -196,9 +201,9 @@ async function runESLintTask (taskName, taskConfig) {
 			`"${path.join(path.dirname(require.resolve('eslint')), '../bin/eslint.js')}"`,
 			includes,
 			newTaskConfig.exclude?.map((exclude) => `--ignore-pattern ${exclude}`).join(' '),
-			`--rulesdir "${path.resolve(__dirname, './eslint/rules/')}"`,
+			`--rulesdir "${path.resolve(dirname, './eslint/rules/')}"`,
 			'--format unix',
-			`--resolve-plugins-relative-to "${__dirname}"`
+			`--resolve-plugins-relative-to "${dirname}"`
 		].filter((argument) => Boolean(argument)).join(' '),
 		taskConfig: newTaskConfig,
 		options: {
@@ -232,7 +237,7 @@ async function runStylelintTask (taskName, taskConfig) {
 		});
 	}
 
-	const stylelintBinPath = getStylelintPath();
+	const stylelintBinPath = await getStylelintPath();
 
 	if (stylelintBinPath === null) {
 		return generateDummyJobOutput(taskName, newTaskConfig, {
@@ -352,10 +357,10 @@ async function runAuditTask (taskName, taskConfig) {
 /**
  * Ensures that the environment in which the linter is running has the correct versions of the required dependencies.
  *
- * @returns {boolean} Returns `true` if the environment is valid, otherwise `false` is returned.
+ * @returns {Promise<boolean>} Returns `true` if the environment is valid, otherwise `false` is returned.
  */
-function validateEnvironment () {
-	const outdatedOverrides = validatePackageOverrides();
+async function validateEnvironment () {
+	const outdatedOverrides = await getOutdatedOverrides();
 
 	if (outdatedOverrides.overrides.length > 0 || outdatedOverrides.resolutions.length > 0) {
 		if (outdatedOverrides.overrides.length > 0) {
@@ -371,7 +376,8 @@ function validateEnvironment () {
 		return false;
 	}
 
-	const missingOverrides = findMissingOverrides().filter(({ name }) => !(npmOrYarn === 'npm' && outdatedOverrides.overrides.some((override) => name === override.name)) && !(npmOrYarn === 'yarn' && outdatedOverrides.resolutions.some((override) => name === override.name)));
+	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)));
 
 	if (missingOverrides.length > 0) {
 		let installCommand;
@@ -567,8 +573,8 @@ function getConfigValue (taskName, taskConfig, optionName) {
 		return taskConfig[optionName];
 	}
 
-	if (taskName in config) {
-		const specificConfig = config[/** @type {keyof typeof config} */(taskName)];
+	if (taskName in linterBundleConfig) {
+		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."
@@ -583,8 +589,8 @@ function getConfigValue (taskName, taskConfig, optionName) {
 		}
 	}
 
-	if (optionName in config) {
-		const configValue = config[/** @type {keyof typeof config} */(optionName)];
+	if (optionName in linterBundleConfig) {
+		const configValue = linterBundleConfig[/** @type {keyof typeof linterBundleConfig} */(optionName)];
 
 		if (Array.isArray(configValue)) {
 			return configValue;

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "linter-bundle",
-	"version": "4.0.3",
+	"version": "5.0.1",
+	"type": "module",
 	"description": "Ready-to use bundle of linting tools, containing configurations for ESLint, stylelint and markdownlint.",
 	"keywords": [
 		"eslint",
@@ -32,12 +33,12 @@
 		"publish:major": "npm version major",
 		"publish:minor": "npm version minor",
 		"publish:patch": "npm version patch",
-		"lint": "npm run _validate-stylelint-options && npm run _stylelint-find-rules && node ./lint files tsc ts md audit --min-severity=critical",
+		"lint": "npm run _test-stylelint && npm run _stylelint-find-rules && node ./lint files tsc ts md audit --min-severity=critical",
 		"preversion": "npm run check-outdated && npm run lint",
 		"postversion": "git push && git push --tags && npm publish",
 		"check-outdated": "npx --yes -- check-outdated --ignore-pre-releases",
-		"_stylelint-find-rules": "stylelint-find-new-rules ./stylelint/index.js",
-		"_validate-stylelint-options": "node ./validate-stylelint-options.mjs"
+		"_stylelint-find-rules": "stylelint-find-new-rules ./stylelint/index.cjs",
+		"_test-stylelint": "node ./test-stylelint.js"
 	},
 	"dependencies": {
 		"@typescript-eslint/eslint-plugin": "6.5.0",
@@ -57,7 +58,7 @@
 		"eslint-plugin-react": "7.33.2",
 		"eslint-plugin-react-hooks": "4.6.0",
 		"eslint-plugin-unicorn": "48.0.1",
-		"markdownlint-cli": "0.35.0",
+		"markdownlint-cli": "0.36.0",
 		"micromatch": "4.0.5",
 		"postcss-scss": "4.0.7",
 		"stylelint": "15.10.3",
@@ -73,8 +74,8 @@
 	"devDependencies": {
 		"@types/eslint": "8.44.2",
 		"@types/micromatch": "4.0.2",
-		"@types/node": "20.5.7",
-		"stylelint-find-new-rules": "4.1.1",
+		"@types/node": "20.5.9",
+		"stylelint-find-new-rules": "4.1.2",
 		"typescript": "5.2.2"
 	}
 }