@alexlit/lint-kit 166.1.0 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/linter/source-code-traverser.js

@@ -1,333 +0,0 @@
-/**
- * @fileoverview Traverser for SourceCode objects.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { parse, matches } = require("./esquery");
-const vk = require("eslint-visitor-keys");
-
-//-----------------------------------------------------------------------------
-// Typedefs
-//-----------------------------------------------------------------------------
-
-/**
- * @import { Language, SourceCode } from "@eslint/core";
- * @import { ESQueryOptions } from "esquery";
- * @import { ESQueryParsedSelector } from "./esquery.js";
- * @import { SourceCodeVisitor } from "./source-code-visitor.js";
- */
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-const STEP_KIND_VISIT = 1;
-const STEP_KIND_CALL = 2;
-
-/**
- * Compares two ESQuery selectors by specificity.
- * @param {ESQueryParsedSelector} a The first selector to compare.
- * @param {ESQueryParsedSelector} b The second selector to compare.
- * @returns {number} A negative number if `a` is less specific than `b` or they are equally specific and `a` <= `b` alphabetically, a positive number if `a` is more specific than `b`.
- */
-function compareSpecificity(a, b) {
-	return a.compare(b);
-}
-
-/**
- * Helper to wrap ESQuery operations.
- */
-class ESQueryHelper {
-	/**
-	 * Creates a new instance.
-	 * @param {SourceCodeVisitor} visitor The visitor containing the functions to call.
-	 * @param {ESQueryOptions} esqueryOptions `esquery` options for traversing custom nodes.
-	 */
-	constructor(visitor, esqueryOptions) {
-		/**
-		 * The visitor to use during traversal.
-		 * @type {SourceCodeVisitor}
-		 */
-		this.visitor = visitor;
-
-		/**
-		 * The options for `esquery` to use during matching.
-		 * @type {ESQueryOptions}
-		 */
-		this.esqueryOptions = esqueryOptions;
-
-		/**
-		 * A map of node type to selectors targeting that node type on the
-		 * enter phase of traversal.
-		 * @type {Map<string, ESQueryParsedSelector[]>}
-		 */
-		this.enterSelectorsByNodeType = new Map();
-
-		/**
-		 * A map of node type to selectors targeting that node type on the
-		 * exit phase of traversal.
-		 * @type {Map<string, ESQueryParsedSelector[]>}
-		 */
-		this.exitSelectorsByNodeType = new Map();
-
-		/**
-		 * An array of selectors that match any node type on the
-		 * enter phase of traversal.
-		 * @type {ESQueryParsedSelector[]}
-		 */
-		this.anyTypeEnterSelectors = [];
-
-		/**
-		 * An array of selectors that match any node type on the
-		 * exit phase of traversal.
-		 * @type {ESQueryParsedSelector[]}
-		 */
-		this.anyTypeExitSelectors = [];
-
-		visitor.forEachName(rawSelector => {
-			const selector = parse(rawSelector);
-
-			/*
-			 * If this selector has identified specific node types,
-			 * add it to the map for these node types for faster lookup.
-			 */
-			if (selector.nodeTypes) {
-				const typeMap = selector.isExit
-					? this.exitSelectorsByNodeType
-					: this.enterSelectorsByNodeType;
-
-				selector.nodeTypes.forEach(nodeType => {
-					if (!typeMap.has(nodeType)) {
-						typeMap.set(nodeType, []);
-					}
-					typeMap.get(nodeType).push(selector);
-				});
-				return;
-			}
-
-			/*
-			 * Remaining selectors are added to the "any type" selectors
-			 * list for the appropriate phase of traversal. This ensures
-			 * that all selectors will still be applied even if no
-			 * specific node type is matched.
-			 */
-			const selectors = selector.isExit
-				? this.anyTypeExitSelectors
-				: this.anyTypeEnterSelectors;
-
-			selectors.push(selector);
-		});
-
-		// sort all selectors by specificity for prioritizing call order
-		this.anyTypeEnterSelectors.sort(compareSpecificity);
-		this.anyTypeExitSelectors.sort(compareSpecificity);
-		this.enterSelectorsByNodeType.forEach(selectorList =>
-			selectorList.sort(compareSpecificity),
-		);
-		this.exitSelectorsByNodeType.forEach(selectorList =>
-			selectorList.sort(compareSpecificity),
-		);
-	}
-
-	/**
-	 * Checks if a node matches a given selector.
-	 * @param {ASTNode} node The node to check
-	 * @param {ASTNode[]} ancestry The ancestry of the node being checked.
-	 * @param {ESQueryParsedSelector} selector An AST selector descriptor
-	 * @returns {boolean} `true` if the selector matches the node, `false` otherwise
-	 */
-	matches(node, ancestry, selector) {
-		return matches(node, selector.root, ancestry, this.esqueryOptions);
-	}
-
-	/**
-	 * Calculates all appropriate selectors to a node, in specificity order
-	 * @param {ASTNode} node The node to check
-	 * @param {ASTNode[]} ancestry The ancestry of the node being checked.
-	 * @param {boolean} isExit `false` if the node is currently being entered, `true` if it's currently being exited
-	 * @returns {string[]} An array of selectors that match the node.
-	 */
-	calculateSelectors(node, ancestry, isExit) {
-		const nodeTypeKey = this.esqueryOptions?.nodeTypeKey || "type";
-		const selectors = [];
-
-		/*
-		 * Get the selectors that may match this node. First, check
-		 * to see if the node type has specific selectors,
-		 * then gather the "any type" selectors.
-		 */
-		const selectorsByNodeType =
-			(isExit
-				? this.exitSelectorsByNodeType
-				: this.enterSelectorsByNodeType
-			).get(node[nodeTypeKey]) || [];
-		const anyTypeSelectors = isExit
-			? this.anyTypeExitSelectors
-			: this.anyTypeEnterSelectors;
-
-		/*
-		 * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor.
-		 * Iterate through each of them, applying selectors in the right order.
-		 */
-		let selectorsByNodeTypeIndex = 0;
-		let anyTypeSelectorsIndex = 0;
-
-		while (
-			selectorsByNodeTypeIndex < selectorsByNodeType.length ||
-			anyTypeSelectorsIndex < anyTypeSelectors.length
-		) {
-			/*
-			 * If we've already exhausted the selectors for this node type,
-			 * or if the next any type selector is more specific than the
-			 * next selector for this node type, apply the any type selector.
-			 */
-			const hasMoreNodeTypeSelectors =
-				selectorsByNodeTypeIndex < selectorsByNodeType.length;
-			const hasMoreAnyTypeSelectors =
-				anyTypeSelectorsIndex < anyTypeSelectors.length;
-			const anyTypeSelector = anyTypeSelectors[anyTypeSelectorsIndex];
-			const nodeTypeSelector =
-				selectorsByNodeType[selectorsByNodeTypeIndex];
-
-			// Only compare specificity if both selectors exist
-			const isAnyTypeSelectorLessSpecific =
-				hasMoreAnyTypeSelectors &&
-				hasMoreNodeTypeSelectors &&
-				anyTypeSelector.compare(nodeTypeSelector) < 0;
-
-			if (!hasMoreNodeTypeSelectors || isAnyTypeSelectorLessSpecific) {
-				anyTypeSelectorsIndex++;
-
-				if (this.matches(node, ancestry, anyTypeSelector)) {
-					selectors.push(anyTypeSelector.source);
-				}
-			} else {
-				selectorsByNodeTypeIndex++;
-
-				if (this.matches(node, ancestry, nodeTypeSelector)) {
-					selectors.push(nodeTypeSelector.source);
-				}
-			}
-		}
-
-		return selectors;
-	}
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Traverses source code and ensures that visitor methods are called when
- * entering and leaving each node.
- */
-class SourceCodeTraverser {
-	/**
-	 * The language of the source code being traversed.
-	 * @type {Language}
-	 */
-	#language;
-
-	/**
-	 * Map of languages to instances of this class.
-	 * @type {WeakMap<Language, SourceCodeTraverser>}
-	 */
-	static instances = new WeakMap();
-
-	/**
-	 * Creates a new instance.
-	 * @param {Language} language The language of the source code being traversed.
-	 */
-	constructor(language) {
-		this.#language = language;
-	}
-
-	static getInstance(language) {
-		if (!this.instances.has(language)) {
-			this.instances.set(language, new this(language));
-		}
-
-		return this.instances.get(language);
-	}
-
-	/**
-	 * Traverses the given source code synchronously.
-	 * @param {SourceCode} sourceCode The source code to traverse.
-	 * @param {SourceCodeVisitor} visitor The emitter to use for events.
-	 * @param {Object} options Options for traversal.
-	 * @param {ReturnType<SourceCode["traverse"]>} options.steps The steps to take during traversal.
-	 * @returns {void}
-	 * @throws {Error} If an error occurs during traversal.
-	 */
-	traverseSync(sourceCode, visitor, { steps } = {}) {
-		const esquery = new ESQueryHelper(visitor, {
-			visitorKeys: sourceCode.visitorKeys ?? this.#language.visitorKeys,
-			fallback: vk.getKeys,
-			matchClass: this.#language.matchesSelectorClass ?? (() => false),
-			nodeTypeKey: this.#language.nodeTypeKey,
-		});
-
-		const currentAncestry = [];
-
-		for (const step of steps ?? sourceCode.traverse()) {
-			switch (step.kind) {
-				case STEP_KIND_VISIT: {
-					try {
-						if (step.phase === 1) {
-							esquery
-								.calculateSelectors(
-									step.target,
-									currentAncestry,
-									false,
-								)
-								.forEach(selector => {
-									visitor.callSync(
-										selector,
-										...(step.args ?? [step.target]),
-									);
-								});
-							currentAncestry.unshift(step.target);
-						} else {
-							currentAncestry.shift();
-							esquery
-								.calculateSelectors(
-									step.target,
-									currentAncestry,
-									true,
-								)
-								.forEach(selector => {
-									visitor.callSync(
-										selector,
-										...(step.args ?? [step.target]),
-									);
-								});
-						}
-					} catch (err) {
-						err.currentNode = step.target;
-						throw err;
-					}
-					break;
-				}
-
-				case STEP_KIND_CALL: {
-					visitor.callSync(step.target, ...step.args);
-					break;
-				}
-
-				default:
-					throw new Error(
-						`Invalid traversal step found: "${step.kind}".`,
-					);
-			}
-		}
-	}
-}
-
-module.exports = { SourceCodeTraverser };

package/packages/config-eslint/node_modules/eslint/lib/linter/source-code-visitor.js

@@ -1,81 +0,0 @@
-/**
- * @fileoverview SourceCodeVisitor class
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-const emptyArray = Object.freeze([]);
-
-//------------------------------------------------------------------------------
-// Exports
-//------------------------------------------------------------------------------
-
-/**
- * A structure to hold a list of functions to call for a given name.
- * This is used to allow multiple rules to register functions for a given name
- * without having to know about each other.
- */
-class SourceCodeVisitor {
-	/**
-	 * The functions to call for a given name.
-	 * @type {Map<string, Function[]>}
-	 */
-	#functions = new Map();
-
-	/**
-	 * Adds a function to the list of functions to call for a given name.
-	 * @param {string} name The name of the function to call.
-	 * @param {Function} func The function to call.
-	 * @returns {void}
-	 */
-	add(name, func) {
-		if (this.#functions.has(name)) {
-			this.#functions.get(name).push(func);
-		} else {
-			this.#functions.set(name, [func]);
-		}
-	}
-
-	/**
-	 * Gets the list of functions to call for a given name.
-	 * @param {string} name The name of the function to call.
-	 * @returns {Function[]} The list of functions to call.
-	 */
-	get(name) {
-		if (this.#functions.has(name)) {
-			return this.#functions.get(name);
-		}
-
-		return emptyArray;
-	}
-
-	/**
-	 * Iterates over all names and calls the callback with the name.
-	 * @param {(name:string) => void} callback The callback to call for each name.
-	 * @returns {void}
-	 */
-	forEachName(callback) {
-		this.#functions.forEach((funcs, name) => {
-			callback(name);
-		});
-	}
-
-	/**
-	 * Calls the functions for a given name with the given arguments.
-	 * @param {string} name The name of the function to call.
-	 * @param {any[]} args The arguments to pass to the function.
-	 * @returns {void}
-	 */
-	callSync(name, ...args) {
-		if (this.#functions.has(name)) {
-			this.#functions.get(name).forEach(func => func(...args));
-		}
-	}
-}
-
-module.exports = { SourceCodeVisitor };

package/packages/config-eslint/node_modules/eslint/lib/linter/timing.js

@@ -1,209 +0,0 @@
-/**
- * @fileoverview Tracks performance of individual rules.
- * @author Brandon Mills
- */
-
-"use strict";
-
-const { startTime, endTime } = require("../shared/stats");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/* c8 ignore next */
-/**
- * Align the string to left
- * @param {string} str string to evaluate
- * @param {number} len length of the string
- * @param {string} ch delimiter character
- * @returns {string} modified string
- * @private
- */
-function alignLeft(str, len, ch) {
-	return str + new Array(len - str.length + 1).join(ch || " ");
-}
-
-/* c8 ignore next */
-/**
- * Align the string to right
- * @param {string} str string to evaluate
- * @param {number} len length of the string
- * @param {string} ch delimiter character
- * @returns {string} modified string
- * @private
- */
-function alignRight(str, len, ch) {
-	return new Array(len - str.length + 1).join(ch || " ") + str;
-}
-
-//------------------------------------------------------------------------------
-// Module definition
-//------------------------------------------------------------------------------
-
-const enabled = !!process.env.TIMING;
-
-const HEADERS = ["Rule", "Time (ms)", "Relative"];
-const ALIGN = [alignLeft, alignRight, alignRight];
-
-/**
- * Decide how many rules to show in the output list.
- * @returns {number} the number of rules to show
- */
-function getListSize() {
-	const MINIMUM_SIZE = 10;
-
-	if (typeof process.env.TIMING !== "string") {
-		return MINIMUM_SIZE;
-	}
-
-	if (process.env.TIMING.toLowerCase() === "all") {
-		return Number.POSITIVE_INFINITY;
-	}
-
-	const TIMING_ENV_VAR_AS_INTEGER = Number.parseInt(process.env.TIMING, 10);
-
-	return TIMING_ENV_VAR_AS_INTEGER > 10
-		? TIMING_ENV_VAR_AS_INTEGER
-		: MINIMUM_SIZE;
-}
-
-/* c8 ignore next */
-/**
- * display the data
- * @param {Object} data Data object to be displayed
- * @returns {void} prints modified string with console.log
- * @private
- */
-function display(data) {
-	let total = 0;
-	const rows = Object.keys(data)
-		.map(key => {
-			const time = data[key];
-
-			total += time;
-			return [key, time];
-		})
-		.sort((a, b) => b[1] - a[1])
-		.slice(0, getListSize());
-
-	rows.forEach(row => {
-		row.push(`${((row[1] * 100) / total).toFixed(1)}%`);
-		row[1] = row[1].toFixed(3);
-	});
-
-	rows.unshift(HEADERS);
-
-	const widths = [];
-
-	rows.forEach(row => {
-		const len = row.length;
-
-		for (let i = 0; i < len; i++) {
-			const n = row[i].length;
-
-			if (!widths[i] || n > widths[i]) {
-				widths[i] = n;
-			}
-		}
-	});
-
-	const table = rows.map(row =>
-		row.map((cell, index) => ALIGN[index](cell, widths[index])).join(" | "),
-	);
-
-	table.splice(
-		1,
-		0,
-		widths
-			.map((width, index) => {
-				const extraAlignment =
-					index !== 0 && index !== widths.length - 1 ? 2 : 1;
-
-				return ALIGN[index](":", width + extraAlignment, "-");
-			})
-			.join("|"),
-	);
-
-	console.log(table.join("\n")); // eslint-disable-line no-console -- Debugging function
-}
-
-/* c8 ignore next */
-module.exports = (function () {
-	const data = Object.create(null);
-	let displayEnabled = true;
-
-	/**
-	 * Time the run
-	 * @param {any} key key from the data object
-	 * @param {Function} fn function to be called
-	 * @param {boolean} stats if 'stats' is true, return the result and the time difference
-	 * @returns {Function} function to be executed
-	 * @private
-	 */
-	function time(key, fn, stats) {
-		return function (...args) {
-			const t = startTime();
-			const result = fn(...args);
-			const tdiff = endTime(t);
-
-			if (enabled) {
-				if (typeof data[key] === "undefined") {
-					data[key] = 0;
-				}
-
-				data[key] += tdiff;
-			}
-
-			return stats ? { result, tdiff } : result;
-		};
-	}
-
-	/**
-	 * Returns a shallow copy of the collected timings data.
-	 * @returns {Record<string, number>} mapping of ruleId to total time in ms
-	 */
-	function getData() {
-		return { ...data };
-	}
-
-	/**
-	 * Merges rule timing totals collected elsewhere into this process' totals.
-	 * @param {Record<string, number>} dataToMerge mapping of ruleId to total time in ms
-	 * @returns {void}
-	 */
-	function mergeData(dataToMerge) {
-		for (const [key, value] of Object.entries(dataToMerge)) {
-			if (typeof data[key] === "undefined") {
-				data[key] = 0;
-			}
-			data[key] += value;
-		}
-	}
-
-	/**
-	 * Disables printing of timing data on process exit.
-	 * Intended for worker threads or non-main contexts.
-	 * @returns {void}
-	 */
-	function disableDisplay() {
-		displayEnabled = false;
-	}
-
-	if (enabled) {
-		process.on("exit", () => {
-			if (displayEnabled && Object.keys(data).length > 0) {
-				display(data);
-			}
-		});
-	}
-
-	return {
-		time,
-		enabled,
-		getListSize,
-		getData,
-		mergeData,
-		disableDisplay,
-	};
-})();