@alexlit/lint-kit 183.1.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/cli-engine/formatters/json-with-metadata.js

@@ -1,16 +0,0 @@
-/**
- * @fileoverview JSON reporter, including rules metadata
- * @author Chris Meyer
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function (results, data) {
-	return JSON.stringify({
-		results,
-		metadata: data,
-	});
-};

package/packages/config-eslint/node_modules/eslint/lib/cli-engine/formatters/json.js

@@ -1,13 +0,0 @@
-/**
- * @fileoverview JSON reporter
- * @author Burak Yigit Kaya aka BYK
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function (results) {
-	return JSON.stringify(results);
-};

package/packages/config-eslint/node_modules/eslint/lib/cli-engine/formatters/stylish.js

@@ -1,153 +0,0 @@
-/**
- * @fileoverview Stylish reporter
- * @author Sindre Sorhus
- */
-"use strict";
-
-const util = require("node:util"),
-	table = require("../../shared/text-table");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Returns a styling function based on the color option.
- * @param {boolean|undefined} color Indicates whether to use colors.
- * @returns {Function} A function that styles text.
- */
-function getStyleText(color) {
-	if (typeof color === "undefined") {
-		return (format, text) =>
-			util.styleText(format, text, { validateStream: true });
-	}
-	if (color) {
-		return (format, text) =>
-			util.styleText(format, text, { validateStream: false });
-	}
-	return (_, text) => text;
-}
-
-/**
- * Given a word and a count, append an s if count is not one.
- * @param {string} word A word in its singular form.
- * @param {number} count A number controlling whether word should be pluralized.
- * @returns {string} The original word with an s on the end if count is not one.
- */
-function pluralize(word, count) {
-	return count === 1 ? word : `${word}s`;
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = function (results, data) {
-	const styleText = getStyleText(data?.color);
-
-	let output = "\n",
-		errorCount = 0,
-		warningCount = 0,
-		fixableErrorCount = 0,
-		fixableWarningCount = 0,
-		summaryColor = "yellow";
-
-	results.forEach(result => {
-		const messages = result.messages;
-
-		if (messages.length === 0) {
-			return;
-		}
-
-		errorCount += result.errorCount;
-		warningCount += result.warningCount;
-		fixableErrorCount += result.fixableErrorCount;
-		fixableWarningCount += result.fixableWarningCount;
-
-		output += `${styleText("underline", result.filePath)}\n`;
-
-		output += `${table(
-			messages.map(message => {
-				let messageType;
-
-				if (message.fatal || message.severity === 2) {
-					messageType = styleText("red", "error");
-					summaryColor = "red";
-				} else {
-					messageType = styleText("yellow", "warning");
-				}
-
-				return [
-					"",
-					String(message.line || 0),
-					String(message.column || 0),
-					messageType,
-					message.message.replace(/([^ ])\.$/u, "$1"),
-					message.ruleId ? styleText("dim", message.ruleId) : "",
-				];
-			}),
-			{
-				align: ["", "r", "l"],
-				stringLength(str) {
-					return util.stripVTControlCharacters(str).length;
-				},
-			},
-		)
-			.split("\n")
-			.map(el =>
-				el.replace(/(\d+)\s+(\d+)/u, (m, p1, p2) =>
-					styleText("dim", `${p1}:${p2}`),
-				),
-			)
-			.join("\n")}\n\n`;
-	});
-
-	const total = errorCount + warningCount;
-
-	/*
-	 * We can't use a single `styleText` call like `styleText([summaryColor, "bold"], text)` here.
-	 * This is a bug in `util.styleText` in Node.js versions earlier than v22.15.0 (https://github.com/nodejs/node/issues/56717).
-	 * As a workaround, we use nested `styleText` calls.
-	 */
-	if (total > 0) {
-		output += `${styleText(
-			summaryColor,
-			styleText(
-				"bold",
-				[
-					"\u2716 ",
-					total,
-					pluralize(" problem", total),
-					" (",
-					errorCount,
-					pluralize(" error", errorCount),
-					", ",
-					warningCount,
-					pluralize(" warning", warningCount),
-					")",
-				].join(""),
-			),
-		)}\n`;
-
-		if (fixableErrorCount > 0 || fixableWarningCount > 0) {
-			output += `${styleText(
-				summaryColor,
-				styleText(
-					"bold",
-					[
-						"  ",
-						fixableErrorCount,
-						pluralize(" error", fixableErrorCount),
-						" and ",
-						fixableWarningCount,
-						pluralize(" warning", fixableWarningCount),
-						" potentially fixable with the `--fix` option.",
-					].join(""),
-				),
-			)}\n`;
-		}
-	}
-
-	// Resets output color, for prevent change on top level
-	return total > 0 ? styleText("reset", output) : "";
-};

package/packages/config-eslint/node_modules/eslint/lib/cli-engine/hash.js

@@ -1,35 +0,0 @@
-/**
- * @fileoverview Defining the hashing function in one place.
- * @author Michael Ficarra
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const murmur = require("imurmurhash");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Private
-//------------------------------------------------------------------------------
-
-/**
- * hash the given string
- * @param {string} str the string to hash
- * @returns {string} the hash
- */
-function hash(str) {
-	return murmur(str).result().toString(36);
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = hash;

package/packages/config-eslint/node_modules/eslint/lib/cli-engine/lint-result-cache.js

@@ -1,220 +0,0 @@
-/**
- * @fileoverview Utility for caching lint results.
- * @author Kevin Partington
- */
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const fs = require("node:fs");
-const fileEntryCache = require("file-entry-cache");
-const stringify = require("json-stable-stringify-without-jsonify");
-const pkg = require("../../package.json");
-const assert = require("../shared/assert");
-const hash = require("./hash");
-
-const debug = require("debug")("eslint:lint-result-cache");
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/** @typedef {import("../types").Linter.Config} Config */
-
-//-----------------------------------------------------------------------------
-// Helpers
-//-----------------------------------------------------------------------------
-
-const configHashCache = new WeakMap();
-const nodeVersion = process && process.version;
-
-const validCacheStrategies = ["metadata", "content"];
-const invalidCacheStrategyErrorMessage = `Cache strategy must be one of: ${validCacheStrategies
-	.map(strategy => `"${strategy}"`)
-	.join(", ")}`;
-
-/**
- * Tests whether a provided cacheStrategy is valid
- * @param {string} cacheStrategy The cache strategy to use
- * @returns {boolean} true if `cacheStrategy` is one of `validCacheStrategies`; false otherwise
- */
-function isValidCacheStrategy(cacheStrategy) {
-	return validCacheStrategies.includes(cacheStrategy);
-}
-
-/**
- * Calculates the hash of the config
- * @param {Config} config The config.
- * @returns {string} The hash of the config
- */
-function hashOfConfigFor(config) {
-	if (!configHashCache.has(config)) {
-		configHashCache.set(
-			config,
-			hash(`${pkg.version}_${nodeVersion}_${stringify(config)}`),
-		);
-	}
-
-	return configHashCache.get(config);
-}
-
-//-----------------------------------------------------------------------------
-// Public Interface
-//-----------------------------------------------------------------------------
-
-/**
- * Lint result cache. This wraps around the file-entry-cache module,
- * transparently removing properties that are difficult or expensive to
- * serialize and adding them back in on retrieval.
- */
-class LintResultCache {
-	/**
-	 * Creates a new LintResultCache instance.
-	 * @param {string} cacheFileLocation The cache file location.
-	 * @param {"metadata" | "content"} cacheStrategy The cache strategy to use.
-	 */
-	constructor(cacheFileLocation, cacheStrategy) {
-		assert(cacheFileLocation, "Cache file location is required");
-		assert(cacheStrategy, "Cache strategy is required");
-		assert(
-			isValidCacheStrategy(cacheStrategy),
-			invalidCacheStrategyErrorMessage,
-		);
-
-		debug(`Caching results to ${cacheFileLocation}`);
-
-		const useChecksum = cacheStrategy === "content";
-
-		debug(`Using "${cacheStrategy}" strategy to detect changes`);
-
-		this.fileEntryCache = fileEntryCache.create(
-			cacheFileLocation,
-			void 0,
-			useChecksum,
-		);
-		this.cacheFileLocation = cacheFileLocation;
-	}
-
-	/**
-	 * Retrieve cached lint results for a given file path, if present in the
-	 * cache. If the file is present and has not been changed, rebuild any
-	 * missing result information.
-	 * @param {string} filePath The file for which to retrieve lint results.
-	 * @param {Config} config The config of the file.
-	 * @returns {Object|null} The rebuilt lint results, or null if the file is
-	 *   changed or not in the filesystem.
-	 */
-	getCachedLintResults(filePath, config) {
-		const cachedResults = this.getValidCachedLintResults(filePath, config);
-
-		if (!cachedResults) {
-			return cachedResults;
-		}
-
-		/*
-		 * Shallow clone the object to ensure that any properties added or modified afterwards
-		 * will not be accidentally stored in the cache file when `reconcile()` is called.
-		 * https://github.com/eslint/eslint/issues/13507
-		 * All intentional changes to the cache file must be done through `setCachedLintResults()`.
-		 */
-		const results = { ...cachedResults };
-
-		// If source is present but null, need to reread the file from the filesystem.
-		if (results.source === null) {
-			debug(
-				`Rereading cached result source from filesystem: ${filePath}`,
-			);
-			results.source = fs.readFileSync(filePath, "utf-8");
-		}
-
-		return results;
-	}
-
-	/**
-	 * Retrieve cached lint results for a given file path, if present in the
-	 * cache and still valid.
-	 * @param {string} filePath The file for which to retrieve lint results.
-	 * @param {Config} config The config of the file.
-	 * @returns {Object|null} The cached lint results if present in the cache
-	 * and still valid; null otherwise.
-	 */
-	getValidCachedLintResults(filePath, config) {
-		/*
-		 * Cached lint results are valid if and only if:
-		 * 1. The file is present in the filesystem
-		 * 2. The file has not changed since the time it was previously linted
-		 * 3. The ESLint configuration has not changed since the time the file
-		 *    was previously linted
-		 * If any of these are not true, we will not reuse the lint results.
-		 */
-		const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
-
-		if (fileDescriptor.notFound) {
-			debug(`File not found on the file system: ${filePath}`);
-			return null;
-		}
-
-		const hashOfConfig = hashOfConfigFor(config);
-		const changed =
-			fileDescriptor.changed ||
-			fileDescriptor.meta.hashOfConfig !== hashOfConfig;
-
-		if (changed) {
-			debug(`Cache entry not found or no longer valid: ${filePath}`);
-			return null;
-		}
-
-		return fileDescriptor.meta.results;
-	}
-
-	/**
-	 * Set the cached lint results for a given file path, after removing any
-	 * information that will be both unnecessary and difficult to serialize.
-	 * Avoids caching results with an "output" property (meaning fixes were
-	 * applied), to prevent potentially incorrect results if fixes are not
-	 * written to disk.
-	 * @param {string} filePath The file for which to set lint results.
-	 * @param {Config} config The config of the file.
-	 * @param {Object} result The lint result to be set for the file.
-	 * @returns {void}
-	 */
-	setCachedLintResults(filePath, config, result) {
-		if (result && Object.hasOwn(result, "output")) {
-			return;
-		}
-
-		const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
-
-		if (fileDescriptor && !fileDescriptor.notFound) {
-			debug(`Updating cached result: ${filePath}`);
-
-			// Serialize the result, except that we want to remove the file source if present.
-			const resultToSerialize = Object.assign({}, result);
-
-			/*
-			 * Set result.source to null.
-			 * In `getCachedLintResults`, if source is explicitly null, we will
-			 * read the file from the filesystem to set the value again.
-			 */
-			if (Object.hasOwn(resultToSerialize, "source")) {
-				resultToSerialize.source = null;
-			}
-
-			fileDescriptor.meta.results = resultToSerialize;
-			fileDescriptor.meta.hashOfConfig = hashOfConfigFor(config);
-		}
-	}
-
-	/**
-	 * Persists the in-memory cache to disk.
-	 * @returns {void}
-	 */
-	reconcile() {
-		debug(`Persisting cached results: ${this.cacheFileLocation}`);
-		this.fileEntryCache.reconcile();
-	}
-}
-
-module.exports = LintResultCache;