linter-bundle 3.10.0 → 4.0.1

package/eslint/overrides-javascript.js

@@ -92,7 +92,7 @@ module.exports = {
 				 *
 				 * @see https://github.com/sindresorhus/eslint-plugin-unicorn
 				 */
-				'unicorn/filename-case': ['error', {
+				'unicorn/filename-case': ['off', { // Disabled in favour of the linter-bundle `files` task
 					cases: {
 						kebabCase: true
 					}

package/eslint/overrides-react.js

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

package/eslint/overrides-type-declarations.js

@@ -28,7 +28,7 @@ module.exports = {
 				 *
 				 * @see https://github.com/sindresorhus/eslint-plugin-unicorn
 				 */
-				'unicorn/filename-case': ['error', {
+				'unicorn/filename-case': ['off', { // Disabled in favour of the linter-bundle `files` task
 					cases: {
 						kebabCase: true,
 						pascalCase: true

package/eslint/rules/no-global-undefined-check.md

@@ -6,7 +6,7 @@ Rendering different output, depending on whether it is SSR or CSR, can lead to h
 
 Examples of **incorrect** code for this rule:
 
-```ts
+```js
 if ('undefined' === typeof window) {}
 if ('undefined' == typeof window) {}
 if (typeof window !== 'undefined') {}

package/eslint/rules/restricted-filenames.js

@@ -6,6 +6,8 @@ const path = require('node:path');
 
 const micromatch = require('micromatch');
 
+const config = require('../../helper/config.js');
+
 /**
  * @type {import('eslint').Rule.RuleModule}
  */
@@ -41,7 +43,8 @@ module.exports = {
 								type: 'string'
 							}
 						}
-					}
+					},
+					required: ['basePath']
 				}
 			]
 		}
@@ -49,7 +52,8 @@ module.exports = {
 	create: (context) => {
 		const filePath = context.getFilename();
 		/** @type {{ basePath: string, allowed?: string[]; disallowed?: string[]; }[]} */
-		const options = context.options;
+		// 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);
 
 		for (const { basePath, allowed, disallowed } of options) {
 			const normalizedName = path.relative(path.join(process.cwd(), basePath), filePath);

package/eslint/rules/restricted-filenames.md

@@ -6,7 +6,7 @@ In projects in which several developers or even teams work together, it is impor
 
 Example configuration for this rule:
 
-```ts
+```js
 'restricted-filenames': ['error', {
   basePath: './src',
   allowed: [
@@ -48,15 +48,17 @@ If only `disallowed` is set, all unspecified files are allowed.
 
 If both are set, `disallowed` wins over `allowed` and all unspecified files are disallowed.
 
-## Glob patterns for different casings
+## Useful reusable code snippets in Glob patterns
 
 | Name | Example | Glob pattern |
 |-|-|-|
-Snake case | number_of_donuts | `[a-z]*(*([a-z0-9])_+([a-z0-9]))` |
-Screaming snake case | NUMBER_OF_DONUTS | `[A-Z]*(*([A-Z0-9])_+([A-Z0-9]))` |
-Kebab case | number-of-donuts | `[a-z]*(*([a-z0-9])-+([a-z0-9]))` |
-Camel case | numberOfDonuts | `[a-z]*([a-zA-Z0-9])` |
-Pascal case | NumberOfDonuts | `[A-Z]*([a-zA-Z0-9])` |
+| Lower case | DONUTS | `[a-z]*([a-z0-9])` |
+| Upper case | donuts | `[A-Z]*([A-Z0-9])` |
+| Snake case | number_of_donuts | `[a-z]*(*([a-z0-9]-)+([a-z0-9]))` |
+| Screaming snake case | NUMBER_OF_DONUTS | `[A-Z]*(*([A-Z0-9]_)+([A-Z0-9]))` |
+| Kebab case | number-of-donuts | `[a-z]*(*([a-z0-9]-)+([a-z0-9]))` |
+| Camel case | numberOfDonuts | `[a-z]*([a-zA-Z0-9])` |
+| Pascal case | NumberOfDonuts | `[A-Z]*([a-zA-Z0-9])` |
 
 ## Glob pattern templates
 
@@ -64,13 +66,15 @@ Instead of defining the same complex patterns over and over again, e.g. for casi
 
 Example of `.eslintrc.js`:
 
-```ts
-const casing = {
-  snake: '[a-z]*(*([a-z0-9])_+([a-z0-9]))',
-  screamingSnake: '[A-Z]*(*([A-Z0-9])_+([A-Z0-9]))',
-  kebab: '[a-z]*(*([a-z0-9])-+([a-z0-9]))',
-  camel: '[a-z]*([a-zA-Z0-9])',
-  pascal: '[A-Z]*([a-zA-Z0-9])'
+```js
+const snippets = {
+  lowerCase: '[a-z]*([a-z0-9])',
+  upperCase: '[A-Z]*([A-Z0-9])',
+  snakeCase: '[a-z]*(*([a-z0-9]_)+([a-z0-9]))',
+  screamingSnakeCase: '[A-Z]*(*([A-Z0-9]_)+([A-Z0-9]))',
+  kebabCase: '[a-z]*(*([a-z0-9]-)+([a-z0-9]))',
+  camelCase: '[a-z]*([a-zA-Z0-9])',
+  pascalCase: '[A-Z]*([a-zA-Z0-9])'
 };
 
 module.exports = {
@@ -78,8 +82,8 @@ module.exports = {
     'restricted-filenames': ['error', {
       basePath: './src',
       allowed: [
-        `components/${casing.pascal}/index.tsx`,
-        `utils/{index.ts,lib/${casing.camel}?(.spec).ts}`
+        `components/${snippets.pascalCase}/index.tsx`,
+        `utils/{index.ts,lib/${snippets.camelCase}?(.spec).ts}`
       ]
     }]
   }

package/files/index.js

@@ -0,0 +1,100 @@
+/**
+ * @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');
+
+const micromatch = require('micromatch');
+
+const config = require('../helper/config.js');
+
+const restrictions = config.files?.restrictions;
+
+if (Array.isArray(restrictions)) {
+	let noOfErrors = 0;
+
+	const argFiles = process.argv.splice(2).map((filePath) => path.join(process.cwd(), filePath));
+
+	/**
+	 * Reports the error to the `console` and increase the error counter.
+	 *
+	 * @param {string} filePath - Path to the file which is not allowed
+	 * @returns {void}
+	 */
+	const report = (filePath) => {
+		process.stderr.write(`Disallowed filename "${filePath}"\n`);
+
+		noOfErrors++;
+	};
+
+	for (const { basePath, allowed, disallowed } of restrictions) {
+		const absoluteBasePath = path.join(process.cwd(), basePath);
+
+		const files = (argFiles.length > 0 ? argFiles.filter((filePath) => !path.relative(absoluteBasePath, filePath).startsWith('..')) : getFiles(absoluteBasePath));
+
+		for (const filePath of files) {
+			const normalizedFilePath = path.relative(absoluteBasePath, filePath);
+
+			if (allowed && !disallowed) {
+				if (!micromatch.isMatch(normalizedFilePath, allowed, { dot: true })) {
+					report(normalizedFilePath);
+
+					continue;
+				}
+			}
+			else if (!allowed && disallowed) {
+				if (micromatch.isMatch(normalizedFilePath, disallowed, { dot: true })) {
+					report(normalizedFilePath);
+
+					continue;
+				}
+			}
+			else if (allowed && disallowed) {
+				if (
+					micromatch.isMatch(normalizedFilePath, disallowed, { dot: true }) ||
+					!micromatch.isMatch(normalizedFilePath, allowed, { dot: true })
+				) {
+					report(normalizedFilePath);
+
+					continue;
+				}
+			}
+		}
+	}
+
+	if (noOfErrors > 0) {
+		process.stderr.write(`\nFound ${noOfErrors} disallowed file${(noOfErrors !== 0 ? 's' : '')}\n`);
+
+		process.exitCode = -1;
+	}
+}
+else {
+	process.stderr.write('No file restrictions found\n');
+
+	process.exitCode = -1;
+}
+
+/**
+ * Returns a list of all files within a given directory.
+ *
+ * @param {string} directory - Base directory for the file search
+ * @param {string[]} [files] - List of files which are already found (is this parameter unset for the initial call)
+ * @returns {string[]} List of files which have been found
+ */
+function getFiles (directory, files = []) {
+	const fileList = fs.readdirSync(directory);
+
+	for (const file of fileList) {
+		const name = `${directory}/${file}`;
+
+		if (fs.statSync(name).isDirectory()) {
+			getFiles(name, files);
+		}
+		else {
+			files.push(name);
+		}
+	}
+
+	return files;
+}

package/helper/config.js

@@ -0,0 +1,48 @@
+/**
+ * @file Returns the `.linter-bundle.js` configuration result.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * @typedef linterBundleConfig
+ * @property {boolean} [verbose]
+ * @property {boolean} [timing]
+ * @property {boolean} [git]
+ * @property {{ tsconfig?: string; }} [tsc]
+ * @property {{ tsconfig?: string; include?: string[]; exclude?: string[]; overrides?: {
+ *   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[]; }
+ *   }
+ * }; }} [ts]
+ * @property {{ patternPrefix?: string; }} [sass]
+ * @property {{ minSeverity?: 'info' | 'low' | 'moderate' | 'high' | 'critical'; exclude?: string[]; }} [audit]
+ * @property {{ restrictions: { basePath: string; allowed?: string[]; disallowed?: string[]; }[]; }} [files]
+ */
+
+module.exports = (
+	loadConfig('.linter-bundle.json') ??
+	loadConfig('.linter-bundle.cjs') ??
+	loadConfig('.linter-bundle.js') ??
+	{}
+);
+
+/**
+ * Load a config file if it exist.
+ *
+ * @param {string} fileName - The name of the config file
+ * @returns {linterBundleConfig | undefined} - Either the file content for `undefined` if the file does not exist.
+ * */
+function loadConfig (fileName) {
+	const filePath = path.join(process.cwd(), fileName);
+
+	// eslint-disable-next-line import/no-dynamic-require -- Required here to load the configuration file.
+	return (fs.existsSync(filePath) ? require(filePath) : undefined);
+}

package/helper/get-git-files.js

@@ -0,0 +1,52 @@
+/**
+ * @file Handling of changed files from Git.
+ */
+
+const { runProcess } = require('./run-process.js');
+
+/** @typedef {import('./run-process').ProcessResult} ProcessResult */
+
+/** @type {{ diff: Promise<ProcessResult>; modified: Promise<ProcessResult>; deleted: Promise<ProcessResult>; } | undefined} */
+let gitFilesProcessPromise;
+/** @type {string[] | undefined} */
+let gitFiles;
+
+/**
+ * Returns a list of changed files based on Git.
+ *
+ * @public
+ * @returns {Promise<string[]>} The list of changed files.
+ */
+async function getGitFiles () {
+	if (!gitFilesProcessPromise) {
+		gitFilesProcessPromise = {
+			// Returns changed files, also stashed and committed
+			diff: runProcess('git diff --name-only -z @{upstream}'),
+			// Returns unstashed files (including deleted)
+			modified: runProcess('git ls-files -o -m --exclude-standard --full-name --deduplicate -z'),
+			// Returns unstashed, deleted files - @todo Is there a way to also get a list of deleted stashed/committed files?
+			deleted: runProcess('git ls-files -d --exclude-standard --full-name --deduplicate -z')
+		};
+	}
+
+	const gitProcessResult = {
+		diff: await gitFilesProcessPromise.diff,
+		modified: await gitFilesProcessPromise.modified,
+		deleted: await gitFilesProcessPromise.deleted
+	};
+
+	if (!gitFiles) {
+		const deletedFiles = gitProcessResult.deleted.stdout.trim().split('\0');
+
+		gitFiles = [
+			...gitProcessResult.diff.stdout.trim().split('\0'),
+			...gitProcessResult.modified.stdout.trim().split('\0')
+		].filter((file, index, self) => !deletedFiles.includes(file) && self.indexOf(file) === index);
+	}
+
+	return gitFiles;
+}
+
+module.exports = {
+	getGitFiles
+};

package/helper/run-process.js

@@ -25,7 +25,8 @@ async function runProcess (command, options) {
 		/** @type {string[]} */
 		const stderr = [];
 
-		const lintingProcess = childProcess.exec(command, { ...options, shell: os.userInfo().shell });
+		// 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 });
 
 		lintingProcess.stdout?.on('data', (/** @type {string} */data) => {
 			stdout.push(data);