@alexlit/lint-kit 175.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint/lib/shared/naming.js

@@ -1,109 +0,0 @@
-/**
- * @fileoverview Common helpers for naming of plugins, formatters and configs
- */
-
-"use strict";
-
-const NAMESPACE_REGEX = /^@.*\//u;
-
-/**
- * Brings package name to correct format based on prefix
- * @param {string} name The name of the package.
- * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter"
- * @returns {string} Normalized name of the package
- * @private
- */
-function normalizePackageName(name, prefix) {
-	let normalizedName = name;
-
-	/**
-	 * On Windows, name can come in with Windows slashes instead of Unix slashes.
-	 * Normalize to Unix first to avoid errors later on.
-	 * https://github.com/eslint/eslint/issues/5644
-	 */
-	if (normalizedName.includes("\\")) {
-		normalizedName = normalizedName.replace(/\\/gu, "/");
-	}
-
-	if (normalizedName.charAt(0) === "@") {
-		/**
-		 * it's a scoped package
-		 * package name is the prefix, or just a username
-		 */
-		const scopedPackageShortcutRegex = new RegExp(
-				`^(@[^/]+)(?:/(?:${prefix})?)?$`,
-				"u",
-			),
-			scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u");
-
-		if (scopedPackageShortcutRegex.test(normalizedName)) {
-			normalizedName = normalizedName.replace(
-				scopedPackageShortcutRegex,
-				`$1/${prefix}`,
-			);
-		} else if (!scopedPackageNameRegex.test(normalizedName.split("/")[1])) {
-			/**
-			 * for scoped packages, insert the prefix after the first / unless
-			 * the path is already @scope/eslint or @scope/eslint-xxx-yyy
-			 */
-			normalizedName = normalizedName.replace(
-				/^@([^/]+)\/(.*)$/u,
-				`@$1/${prefix}-$2`,
-			);
-		}
-	} else if (!normalizedName.startsWith(`${prefix}-`)) {
-		normalizedName = `${prefix}-${normalizedName}`;
-	}
-
-	return normalizedName;
-}
-
-/**
- * Removes the prefix from a fullname.
- * @param {string} fullname The term which may have the prefix.
- * @param {string} prefix The prefix to remove.
- * @returns {string} The term without prefix.
- */
-function getShorthandName(fullname, prefix) {
-	if (fullname[0] === "@") {
-		let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(
-			fullname,
-		);
-
-		if (matchResult) {
-			return matchResult[1];
-		}
-
-		matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(
-			fullname,
-		);
-		if (matchResult) {
-			return `${matchResult[1]}/${matchResult[2]}`;
-		}
-	} else if (fullname.startsWith(`${prefix}-`)) {
-		return fullname.slice(prefix.length + 1);
-	}
-
-	return fullname;
-}
-
-/**
- * Gets the scope (namespace) of a term.
- * @param {string} term The term which may have the namespace.
- * @returns {string} The namespace of the term if it has one.
- */
-function getNamespaceFromTerm(term) {
-	const match = term.match(NAMESPACE_REGEX);
-
-	return match ? match[0] : "";
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = {
-	normalizePackageName,
-	getShorthandName,
-	getNamespaceFromTerm,
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/option-utils.js

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Utilities to operate on option objects.
- * @author Josh Goldberg
- */
-
-"use strict";
-
-/**
- * Determines whether any of input's properties are different
- * from values that already exist in original.
- * @template T
- * @param {Partial<T>} input New value.
- * @param {T} original Original value.
- * @returns {boolean} Whether input includes an explicit difference.
- */
-function containsDifferentProperty(input, original) {
-	if (input === original) {
-		return false;
-	}
-
-	if (
-		typeof input !== typeof original ||
-		Array.isArray(input) !== Array.isArray(original)
-	) {
-		return true;
-	}
-
-	if (Array.isArray(input)) {
-		return (
-			input.length !== original.length ||
-			input.some((value, i) =>
-				containsDifferentProperty(value, original[i]),
-			)
-		);
-	}
-
-	if (typeof input === "object") {
-		if (input === null || original === null) {
-			return true;
-		}
-
-		const inputKeys = Object.keys(input);
-		const originalKeys = Object.keys(original);
-
-		return (
-			inputKeys.length !== originalKeys.length ||
-			inputKeys.some(
-				inputKey =>
-					!Object.hasOwn(original, inputKey) ||
-					containsDifferentProperty(
-						input[inputKey],
-						original[inputKey],
-					),
-			)
-		);
-	}
-
-	return true;
-}
-
-module.exports = {
-	containsDifferentProperty,
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/relative-module-resolver.js

@@ -1,28 +0,0 @@
-/**
- * Utility for resolving a module relative to another module
- * @author Teddy Katz
- */
-
-"use strict";
-
-const Module = require("node:module");
-
-/*
- * `Module.createRequire` is added in v12.2.0. It supports URL as well.
- * We only support the case where the argument is a filepath, not a URL.
- */
-const createRequire = Module.createRequire;
-
-/**
- * Resolves a Node module relative to another module
- * @param {string} moduleName The name of a Node module, or a path to a Node module.
- * @param {string} relativeToPath An absolute path indicating the module that `moduleName` should be resolved relative to. This must be
- * a file rather than a directory, but the file need not actually exist.
- * @returns {string} The absolute path that would result from calling `require.resolve(moduleName)` in a file located at `relativeToPath`
- * @throws {Error} When the module cannot be resolved.
- */
-function resolve(moduleName, relativeToPath) {
-	return createRequire(relativeToPath).resolve(moduleName);
-}
-
-exports.resolve = resolve;

package/packages/config-eslint/node_modules/eslint/lib/shared/runtime-info.js

@@ -1,177 +0,0 @@
-/**
- * @fileoverview Utility to get information about the execution environment.
- * @author Kai Cataldo
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const path = require("node:path");
-const spawn = require("cross-spawn");
-const os = require("node:os");
-const log = require("../shared/logging");
-const packageJson = require("../../package.json");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Generates and returns execution environment information.
- * @returns {string} A string that contains execution environment information.
- */
-function environment() {
-	const cache = new Map();
-
-	/**
-	 * Checks if a path is a child of a directory.
-	 * @param {string} parentPath The parent path to check.
-	 * @param {string} childPath The path to check.
-	 * @returns {boolean} Whether or not the given path is a child of a directory.
-	 */
-	function isChildOfDirectory(parentPath, childPath) {
-		return !path.relative(parentPath, childPath).startsWith("..");
-	}
-
-	/**
-	 * Synchronously executes a shell command and formats the result.
-	 * @param {string} cmd The command to execute.
-	 * @param {Array} args The arguments to be executed with the command.
-	 * @throws {Error} As may be collected by `cross-spawn.sync`.
-	 * @returns {string} The version returned by the command.
-	 */
-	function execCommand(cmd, args) {
-		const key = [cmd, ...args].join(" ");
-
-		if (cache.has(key)) {
-			return cache.get(key);
-		}
-
-		const process = spawn.sync(cmd, args, { encoding: "utf8" });
-
-		if (process.error) {
-			throw process.error;
-		}
-
-		const result = process.stdout.trim();
-
-		cache.set(key, result);
-		return result;
-	}
-
-	/**
-	 * Normalizes a version number.
-	 * @param {string} versionStr The string to normalize.
-	 * @returns {string} The normalized version number.
-	 */
-	function normalizeVersionStr(versionStr) {
-		return versionStr.startsWith("v") ? versionStr : `v${versionStr}`;
-	}
-
-	/**
-	 * Gets bin version.
-	 * @param {string} bin The bin to check.
-	 * @throws {Error} As may be collected by `cross-spawn.sync`.
-	 * @returns {string} The normalized version returned by the command.
-	 */
-	function getBinVersion(bin) {
-		const binArgs = ["--version"];
-
-		try {
-			return normalizeVersionStr(execCommand(bin, binArgs));
-		} catch (e) {
-			log.error(
-				`Error finding ${bin} version running the command \`${bin} ${binArgs.join(" ")}\``,
-			);
-			throw e;
-		}
-	}
-
-	/**
-	 * Gets installed npm package version.
-	 * @param {string} pkg The package to check.
-	 * @param {boolean} global Whether to check globally or not.
-	 * @throws {Error} As may be collected by `cross-spawn.sync`.
-	 * @returns {string} The normalized version returned by the command.
-	 */
-	function getNpmPackageVersion(pkg, { global = false } = {}) {
-		const npmBinArgs = ["bin", "-g"];
-		const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
-
-		if (global) {
-			npmLsArgs.push("-g");
-		}
-
-		try {
-			const parsedStdout = JSON.parse(execCommand("npm", npmLsArgs));
-
-			/*
-			 * Checking globally returns an empty JSON object, while local checks
-			 * include the name and version of the local project.
-			 */
-			if (
-				Object.keys(parsedStdout).length === 0 ||
-				!(parsedStdout.dependencies && parsedStdout.dependencies.eslint)
-			) {
-				return "Not found";
-			}
-
-			const [, processBinPath] = process.argv;
-			let npmBinPath;
-
-			try {
-				npmBinPath = execCommand("npm", npmBinArgs);
-			} catch (e) {
-				log.error(
-					`Error finding npm binary path when running command \`npm ${npmBinArgs.join(" ")}\``,
-				);
-				throw e;
-			}
-
-			const isGlobal = isChildOfDirectory(npmBinPath, processBinPath);
-			let pkgVersion = parsedStdout.dependencies.eslint.version;
-
-			if ((global && isGlobal) || (!global && !isGlobal)) {
-				pkgVersion += " (Currently used)";
-			}
-
-			return normalizeVersionStr(pkgVersion);
-		} catch (e) {
-			log.error(
-				`Error finding ${pkg} version running the command \`npm ${npmLsArgs.join(" ")}\``,
-			);
-			throw e;
-		}
-	}
-
-	return [
-		"Environment Info:",
-		"",
-		`Node version: ${process.version}`,
-		`npm version: ${getBinVersion("npm")}`,
-		`Local ESLint version: ${getNpmPackageVersion("eslint", { global: false })}`,
-		`Global ESLint version: ${getNpmPackageVersion("eslint", { global: true })}`,
-		`Operating System: ${os.platform()} ${os.release()}`,
-	].join("\n");
-}
-
-/**
- * Returns version of currently executing ESLint.
- * @returns {string} The version from the currently executing ESLint's package.json.
- */
-function version() {
-	return `v${packageJson.version}`;
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = {
-	__esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616)
-	environment,
-	version,
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/serialization.js

@@ -1,78 +0,0 @@
-/**
- * @fileoverview Serialization utils.
- * @author Bryan Mishkin
- */
-
-"use strict";
-
-/**
- * Check if a value is a primitive or plain object created by the Object constructor.
- * @param {any} val the value to check
- * @returns {boolean} true if so
- * @private
- */
-function isSerializablePrimitiveOrPlainObject(val) {
-	return (
-		val === null ||
-		typeof val === "string" ||
-		typeof val === "boolean" ||
-		typeof val === "number" ||
-		(typeof val === "object" && val.constructor === Object) ||
-		Array.isArray(val)
-	);
-}
-
-/**
- * Check if a value is serializable.
- * Functions or objects like RegExp cannot be serialized by JSON.stringify().
- * Inspired by: https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript
- * @param {any} val The value
- * @param {Set<Object>} seenObjects Objects already seen in this path from the root object.
- * @returns {boolean} `true` if the value is serializable
- */
-function isSerializable(val, seenObjects = new Set()) {
-	if (!isSerializablePrimitiveOrPlainObject(val)) {
-		return false;
-	}
-	if (typeof val === "object" && val !== null) {
-		if (seenObjects.has(val)) {
-			/*
-			 * Since this is a depth-first traversal, encountering
-			 * the same object again means there is a circular reference.
-			 * Objects with circular references are not serializable.
-			 */
-			return false;
-		}
-		for (const property in val) {
-			if (Object.hasOwn(val, property)) {
-				if (!isSerializablePrimitiveOrPlainObject(val[property])) {
-					return false;
-				}
-				if (
-					typeof val[property] === "object" &&
-					val[property] !== null
-				) {
-					if (
-						/*
-						 * We're creating a new Set of seen objects because we want to
-						 * ensure that `val` doesn't appear again in this path, but it can appear
-						 * in other paths. This allows for reusing objects in the graph, as long as
-						 * there are no cycles.
-						 */
-						!isSerializable(
-							val[property],
-							new Set([...seenObjects, val]),
-						)
-					) {
-						return false;
-					}
-				}
-			}
-		}
-	}
-	return true;
-}
-
-module.exports = {
-	isSerializable,
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/severity.js

@@ -1,49 +0,0 @@
-/**
- * @fileoverview Helpers for severity values (e.g. normalizing different types).
- * @author Bryan Mishkin
- */
-
-"use strict";
-
-/**
- * Convert severity value of different types to a string.
- * @param {string|number} severity severity value
- * @throws error if severity is invalid
- * @returns {string} severity string
- */
-function normalizeSeverityToString(severity) {
-	if ([2, "2", "error"].includes(severity)) {
-		return "error";
-	}
-	if ([1, "1", "warn"].includes(severity)) {
-		return "warn";
-	}
-	if ([0, "0", "off"].includes(severity)) {
-		return "off";
-	}
-	throw new Error(`Invalid severity value: ${severity}`);
-}
-
-/**
- * Convert severity value of different types to a number.
- * @param {string|number} severity severity value
- * @throws error if severity is invalid
- * @returns {number} severity number
- */
-function normalizeSeverityToNumber(severity) {
-	if ([2, "2", "error"].includes(severity)) {
-		return 2;
-	}
-	if ([1, "1", "warn"].includes(severity)) {
-		return 1;
-	}
-	if ([0, "0", "off"].includes(severity)) {
-		return 0;
-	}
-	throw new Error(`Invalid severity value: ${severity}`);
-}
-
-module.exports = {
-	normalizeSeverityToString,
-	normalizeSeverityToNumber,
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/stats.js

@@ -1,30 +0,0 @@
-/**
- * @fileoverview Provides helper functions to start/stop the time measurements
- * that are provided by the ESLint 'stats' option.
- * @author Mara Kiefer <http://github.com/mnkiefer>
- */
-"use strict";
-
-/**
- * Start time measurement
- * @returns {[number, number]} t variable for tracking time
- */
-function startTime() {
-	return process.hrtime();
-}
-
-/**
- * End time measurement
- * @param {[number, number]} t Variable for tracking time
- * @returns {number} The measured time in milliseconds
- */
-function endTime(t) {
-	const time = process.hrtime(t);
-
-	return time[0] * 1e3 + time[1] / 1e6;
-}
-
-module.exports = {
-	startTime,
-	endTime,
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/string-utils.js

@@ -1,58 +0,0 @@
-/**
- * @fileoverview Utilities to operate on strings.
- * @author Stephen Wade
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-// eslint-disable-next-line no-control-regex -- intentionally including control characters
-const ASCII_REGEX = /^[\u0000-\u007f]*$/u;
-
-/** @type {Intl.Segmenter | undefined} */
-let segmenter;
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/**
- * Converts the first letter of a string to uppercase.
- * @param {string} string The string to operate on
- * @returns {string} The converted string
- */
-function upperCaseFirst(string) {
-	if (string.length <= 1) {
-		return string.toUpperCase();
-	}
-	return string[0].toUpperCase() + string.slice(1);
-}
-
-/**
- * Counts graphemes in a given string.
- * @param {string} value A string to count graphemes.
- * @returns {number} The number of graphemes in `value`.
- */
-function getGraphemeCount(value) {
-	if (ASCII_REGEX.test(value)) {
-		return value.length;
-	}
-
-	segmenter ??= new Intl.Segmenter("en-US"); // en-US locale should be supported everywhere
-	let graphemeCount = 0;
-
-	// eslint-disable-next-line no-unused-vars -- for-of needs a variable
-	for (const unused of segmenter.segment(value)) {
-		graphemeCount++;
-	}
-
-	return graphemeCount;
-}
-
-module.exports = {
-	upperCaseFirst,
-	getGraphemeCount,
-};

package/packages/config-eslint/node_modules/eslint/lib/shared/text-table.js

@@ -1,68 +0,0 @@
-/**
- * @fileoverview Optimized version of the `text-table` npm module to improve performance by replacing inefficient regex-based
- * whitespace trimming with a modern built-in method.
- *
- * This modification addresses a performance issue reported in https://github.com/eslint/eslint/issues/18709
- *
- * The `text-table` module is published under the MIT License. For the original source, refer to:
- * https://www.npmjs.com/package/text-table.
- */
-
-/*
- *
- * This software is released under the MIT license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
- * this software and associated documentation files (the "Software"), to deal in
- * the Software without restriction, including without limitation the rights to
- * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
- * the Software, and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
- * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
- * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-"use strict";
-
-module.exports = function (rows_, opts) {
-	const hsep = "  ";
-	const align = opts.align;
-	const stringLength = opts.stringLength;
-
-	const sizes = rows_.reduce((acc, row) => {
-		row.forEach((c, ix) => {
-			const n = stringLength(c);
-
-			if (!acc[ix] || n > acc[ix]) {
-				acc[ix] = n;
-			}
-		});
-		return acc;
-	}, []);
-
-	return rows_
-		.map(row =>
-			row
-				.map((c, ix) => {
-					const n = sizes[ix] - stringLength(c) || 0;
-					const s = Array(Math.max(n + 1, 1)).join(" ");
-
-					if (align[ix] === "r") {
-						return s + c;
-					}
-
-					return c + s;
-				})
-				.join(hsep)
-				.trimEnd(),
-		)
-		.join("\n");
-};