bahlint 28.58.6934

package/lib/shared/translate-cli-options.js

@@ -0,0 +1,223 @@
+/**
+ * @fileoverview Translates CLI options into ESLint constructor options.
+ * @author Nicholas C. Zakas
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { normalizeSeverityToString } = require("./severity");
+const { getShorthandName, normalizePackageName } = require("./naming");
+const { ModuleImporter } = require("@humanwhocodes/module-importer");
+
+//------------------------------------------------------------------------------
+// Types
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../types").ESLint.Options} ESLintOptions */
+/** @typedef {import("../types").Linter.LintMessage} LintMessage */
+/** @typedef {import("../options").ParsedCLIOptions} ParsedCLIOptions */
+/** @typedef {import("../types").ESLint.Plugin} Plugin */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Loads plugins with the specified names.
+ * @param {{ "import": (name: string) => Promise<any> }} importer An object with an `import` method called once for each plugin.
+ * @param {string[]} pluginNames The names of the plugins to be loaded, with or without the "eslint-plugin-" prefix.
+ * @returns {Promise<Record<string, Plugin>>} A mapping of plugin short names to implementations.
+ */
+async function loadPlugins(importer, pluginNames) {
+	const plugins = {};
+
+	await Promise.all(
+		pluginNames.map(async pluginName => {
+			const longName = normalizePackageName(pluginName, "eslint-plugin");
+			const module = await importer.import(longName);
+
+			if (!("default" in module)) {
+				throw new Error(
+					`"${longName}" cannot be used with the \`--plugin\` option because its default module does not provide a \`default\` export`,
+				);
+			}
+
+			const shortName = getShorthandName(pluginName, "eslint-plugin");
+
+			plugins[shortName] = module.default;
+		}),
+	);
+
+	return plugins;
+}
+
+/**
+ * Predicate function for whether or not to apply fixes in quiet mode.
+ * If a message is a warning, do not apply a fix.
+ * @param {LintMessage} message The lint result.
+ * @returns {boolean} True if the lint message is an error (and thus should be
+ * autofixed), false otherwise.
+ */
+function quietFixPredicate(message) {
+	return message.severity === 2;
+}
+
+/**
+ * Predicate function for whether or not to run a rule in quiet mode.
+ * If a rule is set to warning, do not run it.
+ * @param {{ ruleId: string; severity: number; }} rule The rule id and severity.
+ * @returns {boolean} True if the lint rule should run, false otherwise.
+ */
+function quietRuleFilter(rule) {
+	return rule.severity === 2;
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * Translates the CLI options into the options expected by the ESLint constructor.
+ * @param {ParsedCLIOptions} cliOptions The CLI options to translate.
+ * @returns {Promise<ESLintOptions>} The options object for the ESLint constructor.
+ */
+async function translateOptions({
+	cache,
+	cacheFile,
+	cacheLocation,
+	cacheStrategy,
+	concurrency,
+	config,
+	configLookup,
+	errorOnUnmatchedPattern,
+	ext,
+	fix,
+	fixDryRun,
+	fixType,
+	flag,
+	global,
+	ignore,
+	ignorePattern,
+	inlineConfig,
+	parser,
+	parserOptions,
+	plugin,
+	quiet,
+	reportUnusedDisableDirectives,
+	reportUnusedDisableDirectivesSeverity,
+	reportUnusedInlineConfigs,
+	rule,
+	stats,
+	warnIgnored,
+	passOnNoPatterns,
+	maxWarnings,
+}) {
+	const importer = new ModuleImporter();
+
+	let overrideConfigFile =
+		typeof config === "string" ? config : !configLookup;
+	if (overrideConfigFile === false) {
+		overrideConfigFile = void 0;
+	}
+
+	const languageOptions = {};
+
+	if (global) {
+		languageOptions.globals = global.reduce((obj, name) => {
+			if (name.endsWith(":true")) {
+				obj[name.slice(0, -5)] = "writable";
+			} else {
+				obj[name] = "readonly";
+			}
+			return obj;
+		}, {});
+	}
+
+	if (parserOptions) {
+		languageOptions.parserOptions = parserOptions;
+	}
+
+	if (parser) {
+		languageOptions.parser = await importer.import(parser);
+	}
+
+	const overrideConfig = [
+		{
+			...(Object.keys(languageOptions).length > 0
+				? { languageOptions }
+				: {}),
+			rules: rule ? rule : {},
+		},
+	];
+
+	if (
+		reportUnusedDisableDirectives ||
+		reportUnusedDisableDirectivesSeverity !== void 0
+	) {
+		overrideConfig[0].linterOptions = {
+			reportUnusedDisableDirectives: reportUnusedDisableDirectives
+				? "error"
+				: normalizeSeverityToString(
+						reportUnusedDisableDirectivesSeverity,
+					),
+		};
+	}
+
+	if (reportUnusedInlineConfigs !== void 0) {
+		overrideConfig[0].linterOptions = {
+			...overrideConfig[0].linterOptions,
+			reportUnusedInlineConfigs: normalizeSeverityToString(
+				reportUnusedInlineConfigs,
+			),
+		};
+	}
+
+	if (plugin) {
+		overrideConfig[0].plugins = await loadPlugins(importer, plugin);
+	}
+
+	if (ext) {
+		overrideConfig.push({
+			files: ext.map(
+				extension =>
+					`**/*${extension.startsWith(".") ? "" : "."}${extension}`,
+			),
+		});
+	}
+
+	/*
+	 * For performance reasons rules not marked as 'error' are filtered out in quiet mode. As maxWarnings
+	 * requires rules set to 'warn' to be run, we only filter out 'warn' rules if maxWarnings is not specified.
+	 */
+	const ruleFilter =
+		quiet && maxWarnings === -1 ? quietRuleFilter : () => true;
+
+	const options = {
+		allowInlineConfig: inlineConfig,
+		cache,
+		cacheLocation: cacheLocation || cacheFile,
+		cacheStrategy,
+		concurrency,
+		errorOnUnmatchedPattern,
+		fix: (fix || fixDryRun) && (quiet ? quietFixPredicate : true),
+		fixTypes: fixType,
+		flags: flag,
+		ignore,
+		ignorePatterns: ignorePattern,
+		overrideConfig,
+		overrideConfigFile,
+		passOnNoPatterns,
+		ruleFilter,
+		stats,
+		warnIgnored,
+	};
+
+	return options;
+}
+
+module.exports = translateOptions;

package/lib/shared/traverser.js

@@ -0,0 +1,202 @@
+/**
+ * @fileoverview Traverser to traverse AST trees.
+ * @author Nicholas C. Zakas
+ * @author Toru Nagashima
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const vk = require("eslint-visitor-keys");
+const debug = require("debug")("eslint:traverser");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Do nothing.
+ * @returns {void}
+ */
+function noop() {
+	// do nothing.
+}
+
+/**
+ * Check whether the given value is an ASTNode or not.
+ * @param {any} x The value to check.
+ * @returns {boolean} `true` if the value is an ASTNode.
+ */
+function isNode(x) {
+	return x !== null && typeof x === "object" && typeof x.type === "string";
+}
+
+/**
+ * Get the visitor keys of a given node.
+ * @param {Object} visitorKeys The map of visitor keys.
+ * @param {ASTNode} node The node to get their visitor keys.
+ * @returns {string[]} The visitor keys of the node.
+ */
+function getVisitorKeys(visitorKeys, node) {
+	let keys = visitorKeys[node.type];
+
+	if (!keys) {
+		keys = vk.getKeys(node);
+		debug(
+			'Unknown node type "%s": Estimated visitor keys %j',
+			node.type,
+			keys,
+		);
+	}
+
+	return keys;
+}
+
+/**
+ * The traverser class to traverse AST trees.
+ */
+class Traverser {
+	constructor() {
+		this._current = null;
+		this._parents = [];
+		this._skipped = false;
+		this._broken = false;
+		this._visitorKeys = null;
+		this._enter = null;
+		this._leave = null;
+	}
+
+	/**
+	 * Gives current node.
+	 * @returns {ASTNode} The current node.
+	 */
+	current() {
+		return this._current;
+	}
+
+	/**
+	 * Gives a copy of the ancestor nodes.
+	 * @returns {ASTNode[]} The ancestor nodes.
+	 */
+	parents() {
+		return this._parents.slice(0);
+	}
+
+	/**
+	 * Break the current traversal.
+	 * @returns {void}
+	 */
+	break() {
+		this._broken = true;
+	}
+
+	/**
+	 * Skip child nodes for the current traversal.
+	 * @returns {void}
+	 */
+	skip() {
+		this._skipped = true;
+	}
+
+	/**
+	 * Traverse the given AST tree.
+	 * @param {ASTNode} node The root node to traverse.
+	 * @param {Object} options The option object.
+	 * @param {Object} [options.visitorKeys=DEFAULT_VISITOR_KEYS] The keys of each node types to traverse child nodes. Default is `./default-visitor-keys.json`.
+	 * @param {Function} [options.enter=noop] The callback function which is called on entering each node.
+	 * @param {Function} [options.leave=noop] The callback function which is called on leaving each node.
+	 * @returns {void}
+	 */
+	traverse(node, options) {
+		this._current = null;
+		this._parents = [];
+		this._skipped = false;
+		this._broken = false;
+		this._visitorKeys = options.visitorKeys || vk.KEYS;
+		this._enter = options.enter || noop;
+		this._leave = options.leave || noop;
+		this._traverse(node, null);
+	}
+
+	/**
+	 * Traverse the given AST tree recursively.
+	 * @param {ASTNode} node The current node.
+	 * @param {ASTNode|null} parent The parent node.
+	 * @returns {void}
+	 * @private
+	 */
+	_traverse(node, parent) {
+		if (!isNode(node)) {
+			return;
+		}
+
+		this._current = node;
+		this._skipped = false;
+		this._enter(node, parent);
+
+		if (!this._skipped && !this._broken) {
+			const keys = getVisitorKeys(this._visitorKeys, node);
+
+			if (keys.length >= 1) {
+				this._parents.push(node);
+				for (let i = 0; i < keys.length && !this._broken; ++i) {
+					const child = node[keys[i]];
+
+					if (Array.isArray(child)) {
+						for (
+							let j = 0;
+							j < child.length && !this._broken;
+							++j
+						) {
+							this._traverse(child[j], node);
+						}
+					} else {
+						this._traverse(child, node);
+					}
+				}
+				this._parents.pop();
+			}
+		}
+
+		if (!this._broken) {
+			this._leave(node, parent);
+		}
+
+		this._current = parent;
+	}
+
+	/**
+	 * Calculates the keys to use for traversal.
+	 * @param {ASTNode} node The node to read keys from.
+	 * @returns {string[]} An array of keys to visit on the node.
+	 * @private
+	 */
+	static getKeys(node) {
+		return vk.getKeys(node);
+	}
+
+	/**
+	 * Traverse the given AST tree.
+	 * @param {ASTNode} node The root node to traverse.
+	 * @param {Object} options The option object.
+	 * @param {Object} [options.visitorKeys=DEFAULT_VISITOR_KEYS] The keys of each node types to traverse child nodes. Default is `./default-visitor-keys.json`.
+	 * @param {Function} [options.enter=noop] The callback function which is called on entering each node.
+	 * @param {Function} [options.leave=noop] The callback function which is called on leaving each node.
+	 * @returns {void}
+	 */
+	static traverse(node, options) {
+		new Traverser().traverse(node, options);
+	}
+
+	/**
+	 * The default visitor keys.
+	 * @type {Object}
+	 */
+	static get DEFAULT_VISITOR_KEYS() {
+		return vk.KEYS;
+	}
+}
+
+module.exports = Traverser;

package/lib/types/config-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview typings for "eslint/config" module
+ * @author Nicholas C. Zakas
+ */
+
+import {
+	type Config,
+	defineConfig,
+	globalIgnores,
+} from "@eslint/config-helpers";
+
+export { type Config, defineConfig, globalIgnores };