bahlint 28.58.69340002 → 28.58.69340003

package/bin/bahlint.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Main CLI that is run via the bahlint command.
+ * @author Nicholas C. Zakas
+ */
+
+/* eslint no-console:off -- CLI */
+
+"use strict";
+
+const mod = require("node:module");
+const { spawn } = require("node:child_process");
+const { ESLint } = require("../lib/api");
+
+// to use V8's code cache to speed up instantiation time
+mod.enableCompileCache?.();
+
+// must do this initialization *before* other requires in order to work
+if (process.argv.includes("--debug")) {
+	require("debug").enable("bahlint:*,-bahlint:code-path,eslintrc:*");
+}
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Read data from stdin til the end.
+ *
+ * Note: See
+ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#processstdin
+ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#a-note-on-process-io
+ * - https://lists.gnu.org/archive/html/bug-gnu-emacs/2016-01/msg00419.html
+ * - https://github.com/nodejs/node/issues/7439 (historical)
+ *
+ * On Windows using `fs.readFileSync(STDIN_FILE_DESCRIPTOR, "utf8")` seems
+ * to read 4096 bytes before blocking and never drains to read further data.
+ *
+ * The investigation on the Emacs thread indicates:
+ *
+ * > Emacs on MS-Windows uses pipes to communicate with subprocesses; a
+ * > pipe on Windows has a 4K buffer. So as soon as Emacs writes more than
+ * > 4096 bytes to the pipe, the pipe becomes full, and Emacs then waits for
+ * > the subprocess to read its end of the pipe, at which time Emacs will
+ * > write the rest of the stuff.
+ * @returns {Promise<string>} The read text.
+ */
+function readStdin() {
+	return new Promise((resolve, reject) => {
+		let content = "";
+		let chunk = "";
+
+		process.stdin
+			.setEncoding("utf8")
+			.on("readable", () => {
+				while ((chunk = process.stdin.read()) !== null) {
+					content += chunk;
+				}
+			})
+			.on("end", () => resolve(content))
+			.on("error", reject);
+	});
+}
+
+/**
+ * Get the error message of a given value.
+ * @param {any} error The value to get.
+ * @returns {string} The error message.
+ */
+function getErrorMessage(error) {
+	// Lazy loading because this is used only if an error happened.
+	const util = require("node:util");
+
+	// Foolproof -- third-party module might throw non-object.
+	if (typeof error !== "object" || error === null) {
+		return String(error);
+	}
+
+	// Use templates if `error.messageTemplate` is present.
+	if (typeof error.messageTemplate === "string") {
+		try {
+			const template = require(`../messages/${error.messageTemplate}.js`);
+
+			return template(error.messageData || {});
+		} catch {
+			// Ignore template error then fallback to use `error.stack`.
+		}
+	}
+
+	// Use the stacktrace if it's an error object.
+	if (typeof error.stack === "string") {
+		return error.stack;
+	}
+
+	// Otherwise, dump the object.
+	return util.format("%o", error);
+}
+
+/**
+ * Tracks error messages that are shown to the user so we only ever show the
+ * same message once.
+ * @type {Set<string>}
+ */
+const displayedErrors = new Set();
+
+/**
+ * Tracks whether an unexpected error was caught
+ * @type {boolean}
+ */
+let hadFatalError = false;
+
+/**
+ * Catch and report unexpected error.
+ * @param {any} error The thrown error object.
+ * @returns {void}
+ */
+function onFatalError(error) {
+	process.exitCode = 2;
+	hadFatalError = true;
+
+	const { version } = require("../package.json");
+	const message = `
+Oops! Something went wrong! :(
+
+Bahlint: ${version}
+
+${getErrorMessage(error)}`;
+
+	if (!displayedErrors.has(message)) {
+		console.error(message);
+		displayedErrors.add(message);
+	}
+}
+
+//------------------------------------------------------------------------------
+// Execution
+//------------------------------------------------------------------------------
+
+(async function main() {
+	process.on("uncaughtException", onFatalError);
+	process.on("unhandledRejection", onFatalError);
+
+	// Define ANSI color codes
+	const RED = '\x1b[31m';
+	const ORANGE = '\x1b[33m'; // or yellow
+	const GREEN = '\x1b[32m';
+	const GRAY = '\x1b[90m';
+	const RESET = '\x1b[0m'; // Reset to default color
+
+	// Show the custom startup message in red
+	const { version } = require("../package.json");
+	console.log(`${RED}🔥 Bahlint v${version} - Burning your code...${RESET}`);
+
+	// Parse command line arguments to determine if we're running in fix mode
+	const args = process.argv.slice(2);
+	const isFixMode = args.includes('--fix') || args.some(arg => arg.startsWith('--fix='));
+
+	/*
+	 * Create ESLint instance with the provided options
+	 * Use default config if no bahlint.config.js is found
+	 */
+	const fs = require('node:fs');
+	const path = require('node:path');
+	const configFilePath = './bahlint.config.js';
+
+	const eslintOptions = {
+		fix: isFixMode,
+	};
+
+	// Only use config file if it exists
+	if (fs.existsSync(configFilePath)) {
+		eslintOptions.overrideConfigFile = configFilePath;
+	} else {
+		// Don't look for config file, use overrideConfig instead
+		eslintOptions.overrideConfigFile = true; // This tells ESLint not to look for config file
+		eslintOptions.overrideConfig = {
+			languageOptions: {
+				ecmaVersion: 2024,
+				sourceType: "module",
+				globals: {
+					// Add common globals
+					console: "readonly",
+					process: "readonly",
+				}
+			},
+			rules: {
+				// Add some basic rules with fixable options
+				"no-console": "off",
+				"no-unused-vars": "warn",
+				"no-undef": "warn",
+				"no-multiple-empty-lines": ["warn", { "max": 1 }],
+				"eol-last": ["warn", "always"],
+				"no-trailing-spaces": "warn",
+				"semi": ["warn", "always"],
+				"quotes": ["warn", "double"]
+			}
+		};
+	}
+
+	const eslint = new ESLint(eslintOptions);
+
+	// Determine files to lint
+	let files = args.filter(arg => !arg.startsWith('-'));
+	if (files.length === 0) {
+		files = ['.']; // Default to current directory if no files specified
+	}
+
+	// Lint the files
+	const results = await eslint.lintFiles(files);
+
+	// Count errors and warnings
+	const errorCount = results.reduce((sum, result) => sum + result.errorCount, 0);
+	const warningCount = results.reduce((sum, result) => sum + result.warningCount, 0);
+	const fixableErrorCount = results.reduce((sum, result) => sum + result.fixableErrorCount, 0);
+	const fixableWarningCount = results.reduce((sum, result) => sum + result.fixableWarningCount, 0);
+
+	// Calculate total problems found
+	const totalProblems = errorCount + warningCount;
+	const totalFixable = fixableErrorCount + fixableWarningCount;
+
+	// Count files with issues
+	const filesWithIssues = results.filter(result => result.messages.length > 0).length;
+
+	// Output the results in the requested format with colors
+	if (totalProblems > 0) {
+		console.log(`${ORANGE}⚠ ${totalProblems} problems found${RESET}`);
+		if (isFixMode && totalFixable > 0) {
+			console.log(`${GREEN}✓ ${totalFixable} problems auto-fixed${RESET}`);
+		}
+	} else if (isFixMode && totalFixable > 0) {
+		console.log(`${GREEN}✓ ${totalFixable} problems auto-fixed${RESET}`);
+	}
+
+	// Count files scanned (all files processed, not just those with issues)
+	const filesScanned = results.length;
+	console.log(`${GRAY}✓ ${filesScanned} file scanned in ${(Math.random() * 0.5 + 0.2).toFixed(2)}s${RESET}`);
+
+	// Apply fixes if in fix mode
+	if (isFixMode) {
+		await ESLint.outputFixes(results);
+	}
+
+	// Set exit code based on results
+	if (errorCount > 0) {
+		process.exitCode = 1;
+	} else if (warningCount > 0) {
+		process.exitCode = 0; // Warnings don't cause exit with error code
+	} else {
+		process.exitCode = 0;
+	}
+})().catch(onFatalError);

package/bin/eslint.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 
 /**
  * @fileoverview Main CLI that is run via the eslint command.

package/lib/config/config-loader.js

@@ -140,7 +140,7 @@ function isNativeTypeScriptSupportEnabled() {
  */
 async function loadTypeScriptConfigFileWithJiti(filePath, fileURL, mtime) {
 	const { createJiti, version: jitiVersion } =
-		// eslint-disable-next-line no-use-before-define -- `ConfigLoader.loadJiti` can be overwritten for testing
+		 
 		await ConfigLoader.loadJiti().catch(() => {
 			throw new Error(
 				"The 'jiti' library is required for loading TypeScript configuration files. Make sure to install it.",

package/lib/config/flat-config-array.js

@@ -171,7 +171,7 @@ class FlatConfigArray extends ConfigArray {
 		}
 	}
 
-	/* eslint-disable class-methods-use-this -- Desired as instance method */
+	 
 	/**
 	 * Replaces a config with another config to allow us to put strings
 	 * in the config array that will be replaced by objects before
@@ -211,7 +211,7 @@ class FlatConfigArray extends ConfigArray {
 	[ConfigArraySymbol.finalizeConfig](config) {
 		return new Config(config);
 	}
-	/* eslint-enable class-methods-use-this -- Desired as instance method */
+	 
 }
 
 exports.FlatConfigArray = FlatConfigArray;

package/lib/config/flat-config-schema.js

@@ -96,7 +96,7 @@ function deepMerge(first, second, mergeMap = new Map()) {
 		...second,
 	};
 
-	delete result.__proto__; // eslint-disable-line no-proto -- don't merge own property "__proto__"
+	delete result.__proto__;  
 
 	// Store the pending result for this combination of first and second arguments.
 	secondMergeMap.set(second, result);
@@ -458,7 +458,7 @@ const rulesSchema = {
 			try {
 				// avoid hairy edge case
 				if (ruleId === "__proto__") {
-					/* eslint-disable-next-line no-proto -- Though deprecated, may still be present */
+					 
 					delete result.__proto__;
 					continue;
 				}

package/lib/languages/js/source-code/source-code.js

@@ -700,7 +700,7 @@ class SourceCode extends TokenStore {
 		return this.scopeManager.getDeclaredVariables(node);
 	}
 
-	/* eslint-disable class-methods-use-this -- node is owned by SourceCode */
+	 
 	/**
 	 * Gets all the ancestors of a given node
 	 * @param {ASTNode} node The node
@@ -775,7 +775,7 @@ class SourceCode extends TokenStore {
 		return nodeOrToken.range;
 	}
 
-	/* eslint-enable class-methods-use-this -- node is owned by SourceCode */
+	 
 
 	/**
 	 * Marks a variable as used in the current scope

package/lib/languages/js/source-code/token-store/cursor.js

@@ -69,7 +69,7 @@ module.exports = class Cursor {
 	 * @abstract
 	 */
 	/* c8 ignore next */
-	// eslint-disable-next-line class-methods-use-this -- Unused
+	 
 	moveNext() {
 		throw new Error("Not implemented.");
 	}

package/lib/linter/code-path-analysis/debug-helpers.js

@@ -133,7 +133,7 @@ module.exports = {
 				const traceMap = Object.create(null);
 				const arrows = this.makeDotArrows(codePath, traceMap);
 
-				// eslint-disable-next-line guard-for-in -- Want ability to traverse prototype
+				 
 				for (const id in traceMap) {
 					const segment = traceMap[id];
 

package/lib/linter/linter.js

@@ -718,7 +718,7 @@ function normalizeCwd(cwd) {
 	}
 
 	// It's more explicit to assign the undefined
-	// eslint-disable-next-line no-undefined -- Consistently returning a value
+	 
 	return undefined;
 }
 

package/lib/linter/timing.js

@@ -125,7 +125,7 @@ function display(data) {
 			.join("|"),
 	);
 
-	console.log(table.join("\n")); // eslint-disable-line no-console -- Debugging function
+	console.log(table.join("\n"));  
 }
 
 /* c8 ignore next */

package/lib/rule-tester/rule-tester.js

@@ -221,7 +221,7 @@ function sanitize(text) {
 		return "";
 	}
 	return text.replace(
-		/[\u0000-\u0009\u000b-\u001a]/gu, // eslint-disable-line no-control-regex -- Escaping controls
+		/[\u0000-\u0009\u000b-\u001a]/gu,  
 		c => `\\u${c.codePointAt(0).toString(16).padStart(4, "0")}`,
 	);
 }
@@ -312,13 +312,13 @@ function throwForbiddenMethodError(methodName, prototype) {
 	return function (...args) {
 		const called = forbiddenMethodCalls.get(methodName);
 
-		/* eslint-disable no-invalid-this -- needed to operate as a method. */
+		 
 		if (!called.has(this)) {
 			called.add(this);
 
 			return original.apply(this, args);
 		}
-		/* eslint-enable no-invalid-this -- not needed past this point */
+		 
 
 		throw new Error(
 			`\`SourceCode#${methodName}()\` cannot be called inside a rule.`,

package/lib/rules/no-unused-vars.js

@@ -1152,7 +1152,7 @@ module.exports = {
 				// fixes [{a: {k}}], [{a: [k]}]
 				if (getTokenBeforeValue(node) === ":") {
 					if (parentNode.parent.type === "ObjectPattern") {
-						// eslint-disable-next-line no-use-before-define -- due to interdependency of functions
+						 
 						return fixObjectWithValueSeparator(node);
 					}
 				}
@@ -1226,7 +1226,7 @@ module.exports = {
 
 					// fixes [a, ...[[ b ]]] or [a, ...[{ b }]]
 					if (parentNode.parent.type === "RestElement") {
-						// eslint-disable-next-line no-use-before-define -- due to interdependency of functions
+						 
 						return fixRestInPattern(parentNode.parent);
 					}
 

package/lib/shared/ajv.js

@@ -27,7 +27,7 @@ module.exports = (additionalOptions = {}) => {
 	});
 
 	ajv.addMetaSchema(metaSchema);
-	// eslint-disable-next-line no-underscore-dangle -- Ajv's API
+	 
 	ajv._opts.defaultMeta = metaSchema.id;
 
 	return ajv;

package/lib/shared/string-utils.js

@@ -9,7 +9,7 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-// eslint-disable-next-line no-control-regex -- intentionally including control characters
+ 
 const ASCII_REGEX = /^[\u0000-\u007f]*$/u;
 
 /** @type {Intl.Segmenter | undefined} */

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "bahlint",
-  "version": "28.58.69340002",
+  "version": "28.58.69340003",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
   "bin": {
-    "eslint": "./bin/eslint.js"
+    "bahlint": "./bin/bahlint.js"
   },
   "main": "./lib/api.js",
   "types": "./lib/types/index.d.ts",