@alexlit/lint-kit 183.1.0 → 183.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-loop-func.js

@@ -1,273 +0,0 @@
-/**
- * @fileoverview Rule to flag creation of function inside a loop
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Types
-//------------------------------------------------------------------------------
-
-/** @typedef {import("eslint-scope").Reference} Reference */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]);
-
-/**
- * Identifies is a node is a FunctionExpression which is part of an IIFE
- * @param {ASTNode} node Node to test
- * @returns {boolean} True if it's an IIFE
- */
-function isIIFE(node) {
-	return (
-		(node.type === "FunctionExpression" ||
-			node.type === "ArrowFunctionExpression") &&
-		node.parent &&
-		node.parent.type === "CallExpression" &&
-		node.parent.callee === node
-	);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-		dialects: ["typescript", "javascript"],
-		language: "javascript",
-
-		docs: {
-			description:
-				"Disallow function declarations that contain unsafe references inside loop statements",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-loop-func",
-		},
-
-		schema: [],
-
-		messages: {
-			unsafeRefs:
-				"Function declared in a loop contains unsafe references to variable(s) {{ varNames }}.",
-		},
-	},
-
-	create(context) {
-		const SKIPPED_IIFE_NODES = new Set();
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Gets the containing loop node of a specified node.
-		 *
-		 * We don't need to check nested functions, so this ignores those, with the exception of IIFE.
-		 * `Scope.through` contains references of nested functions.
-		 * @param {ASTNode} node An AST node to get.
-		 * @returns {ASTNode|null} The containing loop node of the specified node, or
-		 *      `null`.
-		 */
-		function getContainingLoopNode(node) {
-			for (
-				let currentNode = node;
-				currentNode.parent;
-				currentNode = currentNode.parent
-			) {
-				const parent = currentNode.parent;
-
-				switch (parent.type) {
-					case "WhileStatement":
-					case "DoWhileStatement":
-						return parent;
-
-					case "ForStatement":
-						// `init` is outside of the loop.
-						if (parent.init !== currentNode) {
-							return parent;
-						}
-						break;
-
-					case "ForInStatement":
-					case "ForOfStatement":
-						// `right` is outside of the loop.
-						if (parent.right !== currentNode) {
-							return parent;
-						}
-						break;
-
-					case "ArrowFunctionExpression":
-					case "FunctionExpression":
-					case "FunctionDeclaration":
-						// We need to check nested functions only in case of IIFE.
-						if (SKIPPED_IIFE_NODES.has(parent)) {
-							break;
-						}
-
-						return null;
-					default:
-						break;
-				}
-			}
-
-			return null;
-		}
-
-		/**
-		 * Gets the containing loop node of a given node.
-		 * If the loop was nested, this returns the most outer loop.
-		 * @param {ASTNode} node A node to get. This is a loop node.
-		 * @param {ASTNode|null} excludedNode A node that the result node should not
-		 *      include.
-		 * @returns {ASTNode} The most outer loop node.
-		 */
-		function getTopLoopNode(node, excludedNode) {
-			const border = excludedNode ? excludedNode.range[1] : 0;
-			let retv = node;
-			let containingLoopNode = node;
-
-			while (
-				containingLoopNode &&
-				containingLoopNode.range[0] >= border
-			) {
-				retv = containingLoopNode;
-				containingLoopNode = getContainingLoopNode(containingLoopNode);
-			}
-
-			return retv;
-		}
-
-		/**
-		 * Checks whether a given reference which refers to an upper scope's variable is
-		 * safe or not.
-		 * @param {ASTNode} loopNode A containing loop node.
-		 * @param {Reference} reference A reference to check.
-		 * @returns {boolean} `true` if the reference is safe or not.
-		 */
-		function isSafe(loopNode, reference) {
-			const variable = reference.resolved;
-			const definition = variable && variable.defs[0];
-			const declaration = definition && definition.parent;
-			const kind =
-				declaration && declaration.type === "VariableDeclaration"
-					? declaration.kind
-					: "";
-
-			// Constant variables are safe.
-			if (CONSTANT_BINDINGS.has(kind)) {
-				return true;
-			}
-
-			/*
-			 * Variables which are declared by `let` in the loop is safe.
-			 * It's a different instance from the next loop step's.
-			 */
-			if (
-				kind === "let" &&
-				declaration.range[0] > loopNode.range[0] &&
-				declaration.range[1] < loopNode.range[1]
-			) {
-				return true;
-			}
-
-			/*
-			 * WriteReferences which exist after this border are unsafe because those
-			 * can modify the variable.
-			 */
-			const border = getTopLoopNode(
-				loopNode,
-				kind === "let" ? declaration : null,
-			).range[0];
-
-			/**
-			 * Checks whether a given reference is safe or not.
-			 * The reference is every reference of the upper scope's variable we are
-			 * looking now.
-			 *
-			 * It's safe if the reference matches one of the following condition.
-			 * - is readonly.
-			 * - doesn't exist inside a local function and after the border.
-			 * @param {Reference} upperRef A reference to check.
-			 * @returns {boolean} `true` if the reference is safe.
-			 */
-			function isSafeReference(upperRef) {
-				const id = upperRef.identifier;
-
-				return (
-					!upperRef.isWrite() ||
-					(variable.scope.variableScope ===
-						upperRef.from.variableScope &&
-						id.range[0] < border)
-				);
-			}
-
-			return (
-				Boolean(variable) && variable.references.every(isSafeReference)
-			);
-		}
-
-		/**
-		 * Reports functions which match the following condition:
-		 *
-		 * - has a loop node in ancestors.
-		 * - has any references which refers to an unsafe variable.
-		 * @param {ASTNode} node The AST node to check.
-		 * @returns {void}
-		 */
-		function checkForLoops(node) {
-			const loopNode = getContainingLoopNode(node);
-
-			if (!loopNode) {
-				return;
-			}
-
-			const references = sourceCode.getScope(node).through;
-
-			// Check if the function is not asynchronous or a generator function
-			if (!(node.async || node.generator)) {
-				if (isIIFE(node)) {
-					const isFunctionExpression =
-						node.type === "FunctionExpression";
-
-					// Check if the function is referenced elsewhere in the code
-					const isFunctionReferenced =
-						isFunctionExpression && node.id
-							? references.some(
-									r => r.identifier.name === node.id.name,
-								)
-							: false;
-
-					if (!isFunctionReferenced) {
-						SKIPPED_IIFE_NODES.add(node);
-						return;
-					}
-				}
-			}
-
-			const unsafeRefs = [
-				...new Set(
-					references
-						.filter(r => r.resolved && !isSafe(loopNode, r))
-						.map(r => r.identifier.name),
-				),
-			];
-
-			if (unsafeRefs.length > 0) {
-				context.report({
-					node,
-					messageId: "unsafeRefs",
-					data: { varNames: `'${unsafeRefs.join("', '")}'` },
-				});
-			}
-		}
-
-		return {
-			ArrowFunctionExpression: checkForLoops,
-			FunctionExpression: checkForLoops,
-			FunctionDeclaration: checkForLoops,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-loss-of-precision.js

@@ -1,249 +0,0 @@
-/**
- * @fileoverview Rule to flag numbers that will lose significant figure precision at runtime
- * @author Jacob Moore
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/** Class representing a number in scientific notation. */
-class ScientificNotation {
-	/** @type {string} The digits of the coefficient. A decimal point is implied after the first digit. */
-	coefficient;
-
-	/** @type {number} The order of magnitude. */
-	magnitude;
-
-	constructor(coefficient, magnitude) {
-		this.coefficient = coefficient;
-		this.magnitude = magnitude;
-	}
-
-	/* c8 ignore start -- debug only */
-	toString() {
-		return `${this.coefficient[0]}${this.coefficient.length > 1 ? `.${this.coefficient.slice(1)}` : ""}e${this.magnitude}`;
-	}
-	/* c8 ignore stop */
-}
-
-/**
- * Returns whether the node is number literal
- * @param {Node} node the node literal being evaluated
- * @returns {boolean} true if the node is a number literal
- */
-function isNumber(node) {
-	return typeof node.value === "number";
-}
-
-/**
- * Gets the source code of the given number literal. Removes `_` numeric separators from the result.
- * @param {Node} node the number `Literal` node
- * @returns {string} raw source code of the literal, without numeric separators
- */
-function getRaw(node) {
-	return node.raw.replace(/_/gu, "");
-}
-
-/**
- * Checks whether the number is base ten
- * @param {ASTNode} node the node being evaluated
- * @returns {boolean} true if the node is in base ten
- */
-function isBaseTen(node) {
-	const prefixes = ["0x", "0X", "0b", "0B", "0o", "0O"];
-
-	return (
-		prefixes.every(prefix => !node.raw.startsWith(prefix)) &&
-		!/^0[0-7]+$/u.test(node.raw)
-	);
-}
-
-/**
- * Checks that the user-intended non-base ten number equals the actual number after is has been converted to the Number type
- * @param {Node} node the node being evaluated
- * @returns {boolean} true if they do not match
- */
-function notBaseTenLosesPrecision(node) {
-	const rawString = getRaw(node).toUpperCase();
-	let base;
-
-	if (rawString.startsWith("0B")) {
-		base = 2;
-	} else if (rawString.startsWith("0X")) {
-		base = 16;
-	} else {
-		base = 8;
-	}
-
-	return !rawString.endsWith(node.value.toString(base).toUpperCase());
-}
-
-/**
- * Returns the number stripped of leading zeros
- * @param {string} numberAsString the string representation of the number
- * @returns {string} the stripped string
- */
-function removeLeadingZeros(numberAsString) {
-	for (let i = 0; i < numberAsString.length; i++) {
-		if (numberAsString[i] !== "0") {
-			return numberAsString.slice(i);
-		}
-	}
-	return numberAsString;
-}
-
-/**
- * Returns the number stripped of trailing zeros
- * @param {string} numberAsString the string representation of the number
- * @returns {string} the stripped string
- */
-function removeTrailingZeros(numberAsString) {
-	for (let i = numberAsString.length - 1; i >= 0; i--) {
-		if (numberAsString[i] !== "0") {
-			return numberAsString.slice(0, i + 1);
-		}
-	}
-	return numberAsString;
-}
-
-/**
- * Converts an integer to an object containing the integer's coefficient and order of magnitude
- * @param {string} stringInteger the string representation of the integer being converted
- * @returns {ScientificNotation} the object containing the integer's coefficient and order of magnitude
- */
-function normalizeInteger(stringInteger) {
-	const trimmedInteger = removeLeadingZeros(stringInteger);
-	const significantDigits = removeTrailingZeros(trimmedInteger);
-
-	return new ScientificNotation(significantDigits, trimmedInteger.length - 1);
-}
-
-/**
- * Converts a float to an object containing the float's coefficient and order of magnitude
- * @param {string} stringFloat the string representation of the float being converted
- * @returns {ScientificNotation} the object containing the float's coefficient and order of magnitude
- */
-function normalizeFloat(stringFloat) {
-	const trimmedFloat = removeLeadingZeros(stringFloat);
-	const indexOfDecimalPoint = trimmedFloat.indexOf(".");
-
-	switch (indexOfDecimalPoint) {
-		case 0: {
-			const significantDigits = removeLeadingZeros(trimmedFloat.slice(1));
-
-			return new ScientificNotation(
-				significantDigits,
-				significantDigits.length - trimmedFloat.length,
-			);
-		}
-		case -1:
-			return new ScientificNotation(
-				trimmedFloat,
-				trimmedFloat.length - 1,
-			);
-		default:
-			return new ScientificNotation(
-				trimmedFloat.replace(".", ""),
-				indexOfDecimalPoint - 1,
-			);
-	}
-}
-
-/**
- * Converts a base ten number to proper scientific notation
- * @param {string} stringNumber the string representation of the base ten number to be converted
- * @param {boolean} parseAsFloat if true, the coefficient will be always parsed as a float, regardless of whether a decimal point is present
- * @returns {ScientificNotation} the object containing the number's coefficient and order of magnitude
- */
-function convertNumberToScientificNotation(stringNumber, parseAsFloat) {
-	const splitNumber = stringNumber.split("e");
-	const originalCoefficient = splitNumber[0];
-	const normalizedNumber =
-		parseAsFloat || stringNumber.includes(".")
-			? normalizeFloat(originalCoefficient)
-			: normalizeInteger(originalCoefficient);
-	if (splitNumber.length > 1) {
-		normalizedNumber.magnitude += parseInt(splitNumber[1], 10);
-	}
-
-	return normalizedNumber;
-}
-
-/**
- * Checks that the user-intended base ten number equals the actual number after is has been converted to the Number type
- * @param {Node} node the node being evaluated
- * @returns {boolean} true if they do not match
- */
-function baseTenLosesPrecision(node) {
-	const rawNumber = getRaw(node).toLowerCase();
-	const normalizedRawNumber = convertNumberToScientificNotation(
-		rawNumber,
-		false,
-	);
-	const requestedPrecision = normalizedRawNumber.coefficient.length;
-
-	if (requestedPrecision > 100) {
-		return true;
-	}
-	const storedNumber = node.value.toPrecision(requestedPrecision);
-	const normalizedStoredNumber = convertNumberToScientificNotation(
-		storedNumber,
-		true,
-	);
-
-	return (
-		normalizedRawNumber.magnitude !== normalizedStoredNumber.magnitude ||
-		normalizedRawNumber.coefficient !== normalizedStoredNumber.coefficient
-	);
-}
-
-/**
- * Checks that the user-intended number equals the actual number after is has been converted to the Number type
- * @param {Node} node the node being evaluated
- * @returns {boolean} true if they do not match
- */
-function losesPrecision(node) {
-	return isBaseTen(node)
-		? baseTenLosesPrecision(node)
-		: notBaseTenLosesPrecision(node);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-		dialects: ["typescript", "javascript"],
-		language: "javascript",
-
-		docs: {
-			description: "Disallow literal numbers that lose precision",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-loss-of-precision",
-		},
-		schema: [],
-		messages: {
-			noLossOfPrecision:
-				"This number literal will lose precision at runtime.",
-		},
-	},
-
-	create(context) {
-		return {
-			Literal(node) {
-				if (node.value && isNumber(node) && losesPrecision(node)) {
-					context.report({
-						messageId: "noLossOfPrecision",
-						node,
-					});
-				}
-			},
-		};
-	},
-};